[转载] python字符串数组字典_Python：字符串、列表、元组、字典

参考链接： Python字符串| ascii_uppercase

字符串：

 所有方法都修改不了字符串的值，字符串还是原值；但可以重新赋值；使用字符串方法有返回值

 循环字符串的用法：

 

 字符串方法：

 Name=“hello world”

 Print(name.count(‘b’)) 查询次数

 Print(name.startswith(‘a’)) 字符串是否以a开头

 print(name.capitalize())#首字母大写

 print(name.center(50,'-'))#50个-，把name放中间

 print(name.endswith('u'))#是否以x结尾,是的话返回true

 print(name.expandtabs(30))#补\t的次数

 Print(name.index(‘d’)) 找该元素的下标，找不到时会报错

 print(name.find('n'))#查找字符串的索引,和index用法用法一样，找到返回索引，找不到返回-1

 print(name.format(name='niuniu',age=18))#这个是格式字符串，再第一节的博客里面已经写了

 print(name.format_map({'name':'niuniu','age':19}))#这个也是格式化字符串，后面跟的是一个字典，字典在后面也会写

 Print(name.isidentifier()) 判断是否是个合法的变量名

 Print(name.isspace()) 判断是否全都是空格

 print('abA123'.isalnum())#是否包含数字和字母

 print('abA'.isalpha())#是否是英文字母和汉字

 print('122'.isdigit())#是否是整数

 print('aa'.isidentifier())#是否是一个合法的变量名

 print('aa'.islower())#是否是小写字母

 print('AA'.isupper())#是否是大写字母

 print('Loadrunner Book'.istitle())#是不是一个标题，判断首字母是否大写

 print('+'.join(['hehe','haha','ee']))#拼接字符串或列表，把可迭代对象(字符串 列表 集合 字典等可循环对象)的元素用一个字符拼接起来

 print(''.join(['a','b','12']))  #结果为ab12，可以把列表拼接为字符串

 print(name.lower())#变成小写

 print(name.upper())#变成大写

 print('\nmysql \n'.lstrip())#默认去掉左边的空格和换行

 print('\nmysql \n'.rstrip())#默认去掉右边的空格和换行

 print('\nmysql \n'.strip())#默认去掉两边边的空格和换行

 “mysql”.strip(m),去掉mysql里的m

 p = str.maketrans('abcdefg','1234567')#前面的字符串和后面的字符串做映射

 print('cc ae gg'.translate(p))#输出按照上面maketrans做映射后的字符串

 new_p = str.maketrans('1234567','abcdefg')

 print('cc ae gg'.translate(new_p))

 print('mysql is db.'.replace('mysql','oracle',1))#替换字符串，1代表替换第一个，不指定第几个默认替换所有字符串

 print('mysql is isdb'.rfind('is'))#返回最右边字符的下标

 print('1+2+3+4'.split('+'))#切割字符串，返回一个list。1:按照指定的字符串分割字符串；2：如果split括号里什么都没有的话，按照空格分割

 print('1+2+3\n1+2+3+4'.splitlines())#按照换行符分割

 print('Abcdef'.swapcase())#大小写反转

 字符串格式化format：

 1:'欢迎{name}，今天的日期是{today}'.format(name='宁宁',today=datetime.datetime.today())

 2:''.format_map(dic) #format_map里传字典

 补充：

 import string

 print(string.ascii_letters) #输出所有的大小写字母

 print(string.ascii_lowercase) #输出所有的小写字母

 print(string.ascii_uppercase) #输出所有的大写字母

 print(string.digits) #输出0到9的数字

 print(string.punctuation) 打印出所有的特殊字符，是一个字符串

 列表：

 列表是可变变量

 通过下标修改值

 

 给列表增加值：

 

 从指定位置添加元素，0代表从第一个元素添加。

 给列表删除值：

 

 del names删除变量

 Names.remove(“yuansu”)，remove删除的是列表里的元素，pop删除传的下标

 列表方法：

 只有pop有返回值

 print(len(list))    #打印出列表的长度，即列表有几个元素，结果是数字

 sort:

 nums.sort() ：给nums列表排序，默认升序

 nums.sort(reverse=True):降序。

 reverse:

 nums.reverse()：把列表的值反过来

 count:

 

 取列表里最后一个值：下标是-1，代表最后一个元素，-2代表倒数第二个，以此类推

 index:

 

 

 列表合并：append extend区别：

 两个列表a1,a2：a1.extend(a2)：把a2的元素添加到a1里，a1还是一维数组

 a1.append(a2)把a2数组当成一个元素添加到a1里，a1变成二位数组

 多维数组：

 取值：下图取得是sex

 

 列表取值，切片：

 从列表或字符串里取几个元素出来

 eg1：列表:names=['as','sd','df']

 print(names[0:3]) #取第一和第二个元素，只取0和1下标，顾头不顾尾

 print(names[:]) #取所有的元素

 print(names[:n])#从第一个元素开始取到第n-1个元素

 print(names[n:])#从n元素取到最后一个元素

 print(names[a:b:c]) #从a取到b-1元素，每隔c个取一次；不写c默认隔一个取一个；c为负数时，倒着取值，和reverse方法的功能一样，比如names[::-1],表示从倒数第一个开始取值，取到第一个值，比如names[8:1:-2]

 list[-1] #取倒数第一个元素

 list[::-1] #步长为负时，就是从右向左倒着取值；-2，就是倒着、并隔一个元素取一个值

 list[4:1:-1] #步长为负时，前两个切片的下标也得按照从右往左的顺序写

 list反转的几种方法：

 list.reverse()

 list[::-1]

 eg2 ：字符串：name2='dfhid,dwd'

 方法同上，同列表

 zip() #压缩列表

 stus=['aa','bb','cc']

 sex=['nan','nv','nv']

 age=[20,18,30]

 for a,b,c in zip(stus,sex,age): #不压缩列表的话，会报错

 print(a,b,c)

 元组：

 元组的值不能改变，一旦创建，就不能再改变了 类型是tuple；元组的定义方式是用()，小括号；元组只有两个方法，那就是count和index，用法同list

 tp=(1,2,3f,3,33re)

 print(tp.count(3))

 print(tp.index(3))

 定义元组的时候，如果只有一个元素，要加逗号，否则会被认为是str类型。eg：a=('abc',)

 enumerate(枚举)循环可迭代对象(字符串、列表、元组)

 enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

 例一：

 >>>seasons= ['Spring', 'Summer', 'Fall', 'Winter']

 >>> list(enumerate(seasons))

 打印结果是[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

 例二：

 >>> list(enumerate(seasons, 1))# 下标从 1 开始的意思

 打印结果是[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

 例三：

 >>>seq= ['one', 'two', 'three']

 >>> fori, elementinenumerate(seq):

 printi, element

 打印结果是：0,one   1,two   2,three

 例四：

 >>>seq= ['one', 'two', 'three']

 >>> fori, elementinenumerate(seq,2):

 printi, element

 打印结果是：2,one   3,two   4,three

 字典：

 字典是一种key-value的数据类型，字典的定义使用{}，大括号，每个值用“，”隔开，key和value使用“：”分隔，key不能重复，通过key来取值

 两种取值方法：

 print(dic[‘id’])和print(dic.get(‘id’))

 区别：1，中括号取值，找不到key值会报错，get取值找不到不会报错，会返回None。 2，get取值方法还可以多传一个参数，如果get不到key值，就返回参数，比如print(dic.get(‘id’，‘canshu’)),不写默认返回None

 增加key：

 dic[‘id’]=3           #如果key存在，就修改；如果ke y不存在，就增加

 dic.setdafault(‘addr’,’beijing’)   #如果key存在，值就不变；如果ke y不存在，就增加

 修改key：

 dic[‘id’]=5 #同增加方式一样

 删除：

 del dic[‘id’]

 dic.popitem() #随机删除一个元素

 dic.pop(‘id’) #字典是无序的，pop删除必须得传一个key值

 dic.clear() #清空字典

 内置方法：

 Print(dic.keys()) #返回所有的key

 Print(dic.values()) #返回所有的value

 Print(dic.items()) #返回所有的key和value,，返回的是dict items类型，循环的时候用

 for k,v in dic.items():  print(k,v) #循环出所有的key和value，但因为是dict_items的类型，所以效率较低。效率高的循环是：for k in info:  print(k,info[k]) 这样也是取所有的key和value，效率较高

 info.update(info2) #把两个字典合并，如果有一样的key，则取info2的value

 zip函数：把两个可迭代对象(字符串等)合并到一起

 例子：

 list1=[1,2,3]

 list2=[‘aa’,’bb’,’cc’]

 for I,k in zip(list1,list2):

 print(I,k)

 强制类型转换：

 int() #转换成整型

 float() #转换成浮点型

 str()  #转换成字符串

 list()  #转换成列表

 tuple()  #转换成元组

 eval('{"username":1}') #用它来把字符串转成字典，字符串必须符合字典的格式

 补充：深拷贝、浅拷贝

 不可变变量：(字符串，int，元组，布尔类型)

 eg1：

 a='123'

 b='123' #两个不可变变量，若值相同，则内存地址id(a)和id(b)也相同

 eg2:

 a='abc'

 b=a #a赋值给b，同时也把内存地址赋给它，此时a和b的内存地址一样

 a='sdf' #此时a重新赋值了，所以a的内存地址变了，b还是原来的内存地址

 print(b) #b此时取值是abc

 可变变量：(list，集合，字典)

 eg1:

 lis=[1,2,3]

 lis2=[1,2,3] #两个可变变量,即使值相同，内存地址也是不一样的

 eg2:

 lis=[1,2,3]

 lis2=lis #lis赋值给lis2，同时也把内存地址赋给它，此时它俩内存地址一样

 lis.append('a') #给lis的值改变为[1,2,3,'a']

 print(lis2) #此时lis2的值是[1,2,3,'a']，因为只是改变了lis的值，而不是重新赋值，内存地址没有变，所以同一内存地址的lis2的值也跟着变了

 深拷贝和浅拷贝：

 浅拷贝：1:上述例子中的a=b,lis2=lis,一个变量赋值(也是赋内存地址)给另一个变量，叫做浅拷贝；

 在可变变量的浅拷贝中，一个变量的值改变(不是重新赋值)了，另一个变量的值也会跟着变化，会受影响

 2:另一种浅拷贝是copy模块里的copy.copy，下面另说

 深拷贝：需要用到copy模块

 import copy

 lis=[1,2,3]

 lis2=copy.deepcopy(lis) #深拷贝，只是赋值，并不赋给内存地址

 print(id(lis))

 print(id(lis2)) #深拷贝的两个变量，内存地址是不一样的

 lis.insert(1,8) #改变lis的值

 print(lis2) #lis2的值还是[1,2,3]，并不会跟着lis变化

 copy.copy和copy.deepcopy区别：

 上述例子如果换成copy.copy，两个变量的内存地址也不一样，结果和deepcopy一样；但多维数组时，区别就出来了

 lis=[1,2,3,[5,8]]

 lis2=copy.copy(lis) #浅拷贝，只是赋值，并不赋给内存地址

 lis[3].insert(1,6) #改变lis的值

 print(lis2) #此时结果是[1,2,3,[5,6,8]]；如果用的是deepcopy，结果就是[1,2,3,[5,8]]

 deepcopy的用法：

 eg1：

 nums=[1,1,1,2,2,2,3,3,3,5,6,6,7,8]

 for n in nums:

 if n%2==0:

 nums.remove(n)

 print(nums) #结果是[1, 1, 1, 2, 3, 3, 3, 5, 6, 7]，因为循环的是nums的下标，第一个2下标是3，被删去后，循环的是下标4的数字，所以

 结果中未被删掉的偶数是循环下标时漏掉的

 eg2：用法

 nums=[1,1,1,2,2,2,3,3,3,5,6,6,7,8]

 new_nums=copy.deepcopy(nums)

 for n in new_nums:

 if n%2==0:

 nums.remove(n)

 print(nums) #结果是[1, 1, 1, 3, 3, 3, 5, 7]，循环的是new_nums的下标，删的是nums的值，所以不会存在漏删的情况

 总结：lis2=lis是即赋值、又赋内存地址；copy和deepcopy是只赋值，不赋内存地址；用copy时，在一些情况下(待深入去查哪些情况)，一个变量变化了，

 另一个变量会受影响；用deepcopy时，一变量始终不会受另一变量的影响