python字符串数组字典_Python:字符串、列表、元组、字典

字符串:

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

循环字符串的用法:

字符串方法:

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时,一变量始终不会受另一变量的影响

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值