2 字符串&列表&元祖&集合&字典&浅拷贝和深拷贝(针对可变对象)

1. String'',反斜杠\代表部分符号的本意,也用于特殊字符,如换行符等
   1. *字符串对象调用函数可赋值给其他对象
   2. 切片:截取字符串,字符串变量[起始:结束:步长],包含起始值不包含结束值,步长默认为1,第一个字符的下标为0,负数则为倒数,倒数从-1开始;下标即索引
      1. a[::-1]倒序输出字符串
   3. 连接字符串,必须是相同格式的字符串才能运算
      1. +表示连接字符串
      2. *表示复制字符串
   4. 其他注意:
      1. 逗号在打印的时候表示空格
      2. r用在字符串左边,表示对转义字符取消转义作用
      3. \n换行
2. 输入与输出
   1. print(values,sep,end,file,flush)
      1. values可以是任何多个无名参数,各个值之间用,相隔开,打印出来是空格隔开
      2. sep输入多个打印的值时,各个值之间分割方式
      3. end='\n',默认换行
      4. file=sys.stdout设置输出设备，及把print中的值打印到什么地方
      5. flush=F默认不刷新,当文件对象关闭时才将内容输出到txt文件中;T时,将立刻传到txt中
   2. 输出的格式化操作符:%[(name)][flags][width].[precision]typecode
      1. (name):字典参数,和()是一个整体,同时出现
         1. print('i am a %(key)s'%{key:value,key1:value1})
      2. flag
         1. +正数之前显示'+'
         2. -左对齐
         3. 0数字之前用0填充
         4. %转义出普通的%
      3. width显示宽度
      4. precision小数点后的精度
      5. typecode
         1. %[n]d正数,占用n个字符
         2. %[n].2f浮点数,设定精确到两位小数
         3. %s字符串或数值
         4. %e科学计数法
      6. 字符串外%{key:value}
3. input()输入,能够从用户这里获取输入数据,将获取的数据赋值给相应的变量,一律以字符串的形式保存
4. 字符串常用函数:字符串变量.函数()
   1. *切片:字符串变量[起始:结束:步长];下标即索引,从0开始
   2. find检测字符串是否包含指定字符，如果是返回初始的索引值，否则返回-1
   3. index检测字符串是否包含指定字符，如果是返回初始的索引值，否则提示错误
   4. count返回str1在string中指定索引范围内[start, end)出现的次数
   5. replace将str1中的str1替换成str2，如果指定count，则不超过count次
   6. split如果maxsplit有指定值，则仅分割 maxsplit 个子字符串,返回字符串列表
   7. capitalize将字符串的首字母大写
   8. title将字符串中每个单词的首字母大写
   9. startswith/endwith检查字符串是否是以 obj 开头/结尾, 是则返回 True，否则返回 False
   10. lower/upper将字符串转换为小写/大写
   11. ljust(width,'fillchar')/rjust/center(width,'fillchar')返回一个原字符串左/右对齐/居中,并使用空格填充至长度 width 的新字符串
   12. lstrip/rstrip/strip去除字符串左边/右边/两边空白字符
   13. partition可以将字符串以第一个出现的str1进行分隔成三个部分,[str1前，str1，str1后
   14. join有序对象中每个元素(字符)后面插入str1,构造出一个新的字符串
   15. isspace如果 str1 中只包含空格，则返回 True，否则返回 False
   16. isalnum如果 str1 所有字符都是字母或数字则返回 True,否则返回 False
   17. isdigit如果 str1 只包含数字则返回 True 否则返回 False,小数点被认为字符
   18. isalpha如果 str1 所有字符都是字母 则返回 True,否则返回 False

1. list[]列表
   1. *列表是可变对象,调用函数会修改原对象,并且优先修改原对象而不会赋值给其他对象
   2. 元素之间用,隔开,元素的类型不一定要相同
   3. 列表可以被索引或切片,下标从0开始
   4. 列表可以用'+'拼接操作
   5. 列表中的元素是可变有序的
   6. 列表中嵌套列表时,列表[第一个列表的下标][第二个列表的下标],这样取数,并不代表数组
2. 访问列表:列表可以被索引或切片,下标从0开始
3. 操作列表:会影响原对象
   1. 修改:list[x]='...'
   2. 添加
      1. 列表末尾添加元素list.append('')
      2. 列表中任意位置添加元素list.insert(索引index,'')
   3. 删除
      1. 删除最后一个元素并返回删除值list.pop(index)
      2. 删除元素del list[index]
      3. 删除指定元素值list.remove(元素)
   4. 查找:在与不在,T or F
      1. 元素 in list
      2. 元素 not in list
4. 列表相关函数:function(list)操作对象;list.fun()列表函数
   1. len(list)返回列表元素个数,有序对象都可操作
   2. max(list)返回列表元素中的最大值。默认数值型的参数，取最大值。默认字符型的参数，取字母排序靠后者
   3. min(list)返回列表元素中的最小值。默认数值型的参数，取最小值。默认字符型的参数，取字母排序靠前者
   4. list.count(obj)统计某个元素在列表中出现的次数
   5. extends(list)扩展列表，在一个列表的末尾一次性追加一个新的列表，参数为一个列表
   6. list.index(obj)用于从列表中找出某一个值第一个匹配项的索引位置
   7. list.reverse()反向列表中的元素
   8. list.sort(reverse=T)对列表进行排序，该方法没有返回值。更改的是原数组,=T则从大到小
   9. list.clear()用于清空列表
   10. list.copy()复制列表

1. tuple()元祖
   1. 用,分隔
   2. tuple的元素不可变有序,但可以包含可变的元素,如列表
   3. 构造包含0个或者1个元素的tuple有特殊语法;tuple的输出也是带括号的
      1. tuple=()
      2. tuple=(1,),一个元素必须加上",",不然会返回数值或字符串
   4. 元祖可以被索引或切片,tuple[index]
2. 元祖的操作
   1. 删除元祖:元祖中的元素值是不允许被单独修改和删除的,但是可以del tuple
      1. 间接删除:list(tuple)->tuple(list),元祖转化为列表修改后,再转回来
      2. 强制类型转换函数:list();tuple();int();str();dict()
   2. 多维元祖:多维元祖就是元祖中的元祖，元祖中的元素可以是一个新的元祖tuple[][]
      1. 多维元祖,如果元素是列表等可变对象,可以直接修改

1. sets{}集合:确定性,互异性,无序性
2. dictionary{}字典
   1. 映射类型,无序的键key:值value对集合
      1. 不能索引或切片
   2. 键值对用,隔开
   3. 键必须是不可变类型,且键必须是唯一的;值则无要求
3. 对象,都可以是变量
   1. 不可变:数值,字符串,元祖
   2. 可变:列表,字典
   3. 可变有序:列表list[]
   4. 不可变有序:元祖tuple()
   5. 可变无序:dictionary{},sets{}
4. 字典操作
   1. *所有对象类型都用[]来定位
   2. 访问字典dict[key]
   3. 添加元素dict[new_key]=new_value
   4. 修改字典dict[key]=value
   5. 删除字典del dict[key]/del dict,删除一个元素或全部删除
   6. 清空字典dict.clear()
5. 字典函数
   1. len(dict)计算字典中元素的个数
   2. str(dict)输出字典，以可打印的字符串表示
   3. type(variable)返回输入变量的数据类型，如果变量是字典就返回<class ‘dict’>
   4. dict.fromkeys(seq[,value])创建一个新字典，以序列(列表或元祖)seq中元素做字典的键，value为字典所有键对应的初始值
   5. dict.get(key,default=None)返回指定键的值，如果值不在字典中返回default值
   6. dict.setdefault(key,default=None)和get类似,键存在则返回值,但如果键不存在于字典中，将会添加键并将值设为default
   7. key in dict如果键在字典dict里返回true,否则返回false
   8. dict.keys()以列表返回一个字典所有的键
   9. dict.values()以列表返回一个字典中的所有值

1. 浅拷贝
   1. 方法
      1. copy.copy():copy模块的copy方法
      2. list.copy():列表对象的copy方法
      3. list[:]:列表起始到结束的切片
      4. list(list):强制类型转换对象的类型
   2. 可变对象里面的子对象是不可变对象时,修改子对象不会影响原对象;子对象是可变对象时,修改子对象会影响原对象和其他浅拷贝对象
2. 深拷贝
   1. 方法
      1. copy.deepcopy():copy模块的deepcopy方法
   2. 不管你的子对象是可变还是不可变对象,都不会影响原对象
3. 特点:修改的是对象的元素
   1. 可变对象:修改对象(是方法等)是在原对象的基础上进行修改,没有返回值
   2. 不可变对象:修改对象是不会影响原对象,有返回值
4. 可变对象的直接赋值:相当于双胞胎,几乎一致,任何修改都相互影响

1. 列表
   1. 增
      1. list.append()列表末尾添加元素
      2. list.insert(index,'')列表中任意位置添加元素
      3. list.extend()列表的末尾一次性追加一个新的列表
   2. 删
      1. list.remove(value)删除指定元素值
      2. list.pop()删除最后一个元素并返回删除值,即弹出
      3. list.clear()清空列表
      4. del list[index]删除元素
   3. 改
      1. list[index]=''
   4. 查
      1. list[index]
      2. list.index(元素)返回元素索引
2. 元祖:无法直接增删改查,可以转换成列表进行增删改查
3. 字典:
   1. 增
      1. dict[new_key]=new_value添加元素
      2. dict.setdefault(key,default=None)和get类似,键存在则返回值,但如果键不存在于字典中，将会添加键并将值设为default
      3. dict.update(dict1)将字典对象添加到dict中
   2. 删
      1. del dict[key]/del dict,删除一个元素/全部删除
      2. dict.clear()清空字典
      3. dict.pop(key,default=None)至少需要1个变量,没有则报错,因为是无序的不能弹出最后一个,根据key删除键,没有则default(default必须有)
      4. dict.popitem()随意删除1个key:value
   3. 改
      1. dict[key]=value修改字典
   4. 查
      1. dict[key]查看值
      2. dict.keys()
      3. dict.values()
      4. dict.item()遍历key:value
      5. dict.get(key,default=None)返回指定键的值，如果值不在字典中返回default值

1. 内置函数:dir(__builtins__)查询
   1. 数学运算
      1. abs
      2. divmod返回两个数值的商和余数组成的元祖
      3. max返回可迭代对象中的最大值
      4. min
      5. pow前两个参数是幂运算值,第三个参数取模运算
      6. round
      7. sum对元素类型是数值的可迭代对象中的每个元素进行求和,sum(list)
   2. 类型转换
      1. bool根据你所传入的参数的逻辑值进行判断,返回True或者False;有元素存在即T,没有为F
      2. int不识别字符串
      3. float识别字符串
      4. complex
      5. str
      6. bin将整数转换成2进制字符串
      7. oct将整数转换成8进制字符串
      8. hex将整数转换成16进制字符串
      9. tuple将传入的参数转换成元祖
      10. list
      11. dict
      12. enumerate根据可迭代对象创建枚举对象,具体为list(enumerate(list))=[(0,list_element_1),(1,list_element_2)]
      13. range根据所传入的参数创建一个新的range对象,range(start,end,step),左闭右开,一般配合list(range())
          1. 一个数字x代表从0开始的x个元素的序列
      14. slice返回的是切片对象,一般配合为list(range()[slice()]),slice(start,end,step)左闭右开
   3. 序列操作:
      1. all判断可迭代对象的每个元素是否都为True,list中的0即为F,空list和空tuple为T
      2. any判断可迭代对象里面的元素是否有True值的元素,空list和空tuple为F
      3. filer
      4. map
      5. next
      6. reversed反转序列生成新的可迭代对象,list(reversed(range()))
      7. sorted默认从小到大排序,sorted(list,reverse=F)
      8. zip将传入的两个序列位置元素一一对应,返回一个新的迭代对象;只返回能对应的映射,不会循环,取较少的序列的元素个数
   4. 对象操作:
      1. help返回对象的帮助信息,help(list)
      2. dir返回当前作用域的属性列表,包含对象的方法
      3. id返回对象的唯一标志,在浅拷贝中出现的概念,可变对象指向某个id
      4. type
      5. len
      6. format
      7. vars返回当前作用域方法或者属性与值组成的字典,或者属性列表,var(list)
   5. 交互操作:
      1. print
      2. input
   6. 编译执行:
      1. eval执行字符串类型表达式的值,print(eval()),eval有返回值
      2. exec直接执行复杂的python代码,exec(''),exec没有返回值

• • • • ee=input('请输入你要计算的求和式子:'),ee截取输入,转化为string
      • print(eval(ee))直接输出求和结果