python学习day03 int str bool 列表 字典 元组 集合 操作函数
一.数据类型
1. int 整型 bit_length() 返回整型数值的二进制长度
a = 15 #15的二进制码是1111,当然存储是以字节为单位的00001111,看电脑是32位还是64位在前补零 print(a.bit_length()) # 求的是有效长度,从第一个不为0开始数 #4
2. str
除了赋值操作,任何以下的函数都不会改变原字符串,只会返回一个新的字符串.列表则不同.函数操作是直接在原列表上进行的,
字符串的增使用"+"连接,倍增用 "*" 连接 ,删replace替换strip去除左右两端的字符,切片,split切割列表,查find.index
列表的增insert append extend ,删 pop remove del clear ,改切片直接赋值,没有replace, 查index
字典的增,直接dic[]="",updata,删 pop del,改直接赋值,查dic["name"] 遍历查
s="abcdefg" s[2] #索引 s[2:3] #切片 s.split(**) #切割,返回列表 s.count(**) #数数,返回个数 s.find(**) #返回索引 s.index(**) #返回索引 len(s) #返回字符串的长度,和print一样是Python的内置函数
*****以下是条件判断语句返回True或者False s.startswith(**) #判断字符串是否以**开头,返回True或者False s.endswith(**) #判断字符串是否以**结尾,返回True或者False s.isalnum() #判断字符串是否是中文字母和数字组成 s.isdigit() #判断字符串是否是纯阿拉伯数字 s.isalpha() #判断字符串是否是字母或中文
s.encode("utf-8").isalpha #判断字符串是否为全英文
s.isnumeric() #判断字符串是否是数字,包括一二三 个十百 壹贰这些 *****判断语句结束******** "abc{}".format() #格式化输出
*******字符串大小写字母的问题****** s.capitalize() #字符串首字母变为大写,其余字母变为小写,原来是大写也变为小写 s.title() #所有单词(被特殊字符分割都认为是单词,中文也算特殊字符)首字母变为大写 s.upper() #变为大写字母 s.lower() #变为小写字母 s.swapcase() #大小写互换
s.center(10,"*") #拉长成10, 把原字符串放中间.其余位置补* s.expandtabs() s.strip() #去掉左右两端的空格 s.strip("**") #去掉左右两端指定元素
s.strip("a" "b") #去掉左右两端的"a"和"b"
s.replace("原字符","新字符","替换的个数")
#######索引 s="abcdefg1234567" print(s[2]) #从0开始从左往右数,所以这里打印的是第三个字符"字" #c print(s[-1]) #-1表示的是倒数第一个 #7 ######切片 print(s[1:4]) #输出索引位置为 1 2 3出的字符,注意这个[]只包括左边的数,顾头不顾尾 #bcd print(s[1:4:2]) #2为步长,每两个输出一个,输出第一个 #bd print(s[4:1:-1]) #要想从右往左输出,步长必须为负,即当s[第一个索引:第二个索引:步长],第一个索引对应字符串在第二个索引左边时,步长必须为正,默认是1,第一个索引对应的字符串在第二个索引的右边时,则步长必须为负 # edc print(s[-1:-4:-2]) #75 print(s[1:])#从索引1处到最后 #bcdefg1234567 print(s[:-1])#从开始到倒数第二个,-1是最后一个,但是注意[]顾头不顾尾 #abcdefg123456 print(s[:])#原样输出
######切割 split s="a_b_c_d_e" li=s.split("_") #以下划线作为刀切割字符串,原字符串中所有下滑线的左右两侧变为两个字符串,并返回一个列表,即字符或者字符串如作为刀则一定能切,且至少切成两份 print(li) #['a', 'b', 'c', 'd', 'e'] li=s.split("_",2) #第二个参数是切得个数,从左到右开始切,切两次就不切了 print(li) #['a', 'b', 'c_d_e'] li=s.split("g") #字符串中没有刀,不能切,返回原字符串 print(li) #['a_b_c_d_e'] #li=s.split("") #这个刀为空,报错, li=s.split("a") #所谓一刀两断,a的左边认为是空字符 print(li) #['', '_b_c_d_e']
s = "abc s k " li = s.strip().split(" ") print(li) ['abc', '', '', 's', '', '', 'k'] 这是按空格切出来的结果会有很多空字符串 while "" in li: li.remove("") #清除空字符串, print(li) # 或者使用下面这种方法 li = [i for i in li if i!=""] #清除空字符串 print(li) # 其实直接使用split() 不加参数切就行了 li = s.strip().split() print(li) #['abc', 's', 'k']
s = """诗人 学者 感叹号 渣渣""" print(s.split("\n")) # 用\n切割
count 数数
s = "alex wusir taibai " print(s.count("ai")) #输出ai在s字符串中的个数 #2
find 查找
s = "明天周末了.你们打算干什么去?" print(s.find("了")) # 如果查找的内容不存在. 返回-1, 如果存在返回索引 #4 print(s.find("我")) #-1
s.find("a", 8, 22) # 切片找,从索引为8-21中找"a"的索引位置
index 求索引
#index 求索引 s = "下周我们要考试了. 你们慌不慌" print(s.index("们要")) #3
format 格式化输出
#格式化输出 print("我叫%s,今年%d岁" % ("perfey",24)) #我叫perfey,今年24岁 print("我叫{},今年{}岁".format("perfey",24)) #我叫perfey,今年24岁 print("我叫{1},今年{0}岁".format(24,"perfey")) #可以指定参数的位置,不必按顺序对应了 #我叫perfey,今年24岁 print("我叫{name},今年{age}岁".format(name="perfey",age=24)) #通过有意义的名称作为参数进行对应 #我叫perfey,今年24岁
3. bool
True False
认为字符串有内容为真,无内容为假. 即只有""字符串为假,其余的字符串均为真
空字符串是False. 非空字符串是True
向系统中录入员工信息, 不停的录入 , 输入回车退出 while True: name = input("输入用户信息:") if not name: 当不输入信息即直接回车时,name为空,认为是False break else: print("新员工信息:"+name)
for 迭代
for 变量 in s: #把s中的元素逐个的放到变量中 代码块
int str bool三种类型的转换
str => int int(str)
int => str str(int)
int => bool bool(int). 0是False 非0是True
bool=>int int(bool) True是1, False是0
str=>bool 在判断语句中如 if while不用转换,解释器自己转换;在其他语句中 bool(str)
s="" if not s: print(bool(s)) #False
4. list [] 列表
字符串转化为列表,可以使用split或者extend,但是因为split切割时会有消耗,所以一般使用extend进行迭代的追加
************************列表******************* li=[1,'a','b',2,3,'a'] li.insert(0,55) #按索引插入 li.append('aaa') #增加到最后 li.extend(['q,a,w','aaa']) # 迭代的增加 用[]括起来表示是一个元素 #[1, 'a', 'b', 2, 3, 'a', 'q,a,w', 'aaa'] li.extend('a') li.extend('abc') #把字符串的每个元素分别作为元素加入到列表后面 li.extend('a,b,c') li.pop(1) #从0开始数,把第一个元素删除.有返回值返回删除的元素
pop是堆栈中的概念,相对于push,向外弹,从后往前弹
li.pop() #删除最后的值
del li[1:3] #把1 2元素删除,注意这个[]是类似于前闭后开,没有3元素.没有返回值.del不是函数,只要是函数就有小括号,del是关键字 print(li) li.remove('a') #删除指定的元素 li.clear() #清空列表所有元素 li=[1,2,3,4,5] li[1]='11' #将索引2处的值改为11 print(li) li[2:4]='ab' #将索引 2 3 处的值改为 "a" "b" print(li) #[1, '11', 'a', 'b', 5] li[2:4]=['ab','c'] #将索引 2 3 处的值改为 "ab" "c" print(li) #[1, '11', 'ab', 'c', 5]
li[0:4:2]="ab" #步长为2,步长不为1时元素个数必须要匹配,不匹配会报错
#[a,"11","b","c",5]
print(li.count(5)) #列表中有多少个5 print(li.index('11')) #查找某个值的索引 a=[2,1,3,4,5] a.sort() #将a中的元素排序 print(a) #[1, 2, 3, 4, 5]
a.sort(reverse=True) #降序
#[5, 4, 3, 2, 1]
a=["1","12","112","5","9"]
a.sort()
#['1', '112', '12', '5', '9'] #这里是字符串,是一位一位进行比较排序的,注意汉字不能排序
a=[2,1,3,4,5] a.reverse() #将a中的元素反向排列 print(a) #[5, 4, 3, 1, 2]
s = "*".join(lst) # 把列表变成字符串. 用前面的字符串"*"把列表连接起来, 返回新字符串 (字符串\元组也有同样的操作,可迭代,有顺序)
lst = ["黄飞鸿", "霍元甲", "十三姨", "鬼脚七"]
s = "_*_".join(lst) # 把列表变成字符串. 用前面的字符串把列表连接起来, 返回新字符串
print(s)
#黄飞鸿_*_霍元甲_*_十三姨_*_鬼脚七
s = "金毛狮王"
s1 = "_".join(s) # 迭代把每一项进行拼接
print(s1)
# 金_毛_狮_王
tu = ('你好', "你不好", "你好不好")
s = "".join(tu)
print(s)
# 你好你不好你好不好
#join 和 split结合使用可以字符串变成列表
s = "你今天准备什么时候睡觉"
s1 = "_".join(s) # 你_今_天_...
lst = s1.split("_")
print(lst)
# ['你', '今', '天', '准', '备', '什', '么', '时', '候', '睡', '觉']
5. tupe () 元组,只读列表,不能更改
tupe () 元组 只读列表 可以被查询,不能修改,字符串的切片操作也可用于元组
元组和列表之间可以直接转化
tu1 = tuple(lst)
lst1 = list(tu1)
tu=(1,) 如果只有一个元素,元素后边必须加逗号
tupe本身不能变,但是二级元素可以变,tupe的儿子不可变,孙子可变
6. dict {} 字典,查找比较快. key:value, 一次存两个数据. 一对一对的存
**********************************字典************************************* dic={'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'} #定义了一个字典 print(dic) #字典的顺序是哈希算法决定的,与我们输入的顺序无关,所以字典不能切片 print(dic['age']) #输出键'age'对应的值,注意这里的键的数据类型是字符还是变量还是整型的 #18 print("name" in dic) # 看字典中是否有"name这个键值" #True dic[5]=9 #新增键值对,在最后增加,原字典中有键值的话会修改为现在的value print(dic) #{'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v', 5: 9} dic.setdefault('k','v1') #setdefault(设置默认值) 在字典中添加键值对，返回值是value,如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖 print(dic) #{'age': 20, 'name': 'jin', 'sex': 'male', 'k': 'v'} dic["age"]=20 #更改键对应的值 print(dic) #{'age': 20, 'name': 'jin', 'sex': 'male', 'k': 'v', 5: 9} del dic[5] #删除键值对,这个是删除键5对应的键值对.没有返回值 print(dic) #{'age': 20, 'name': 'jin', 'sex': 'male', 'k': 'v'} dic.pop("k") #删除"k"对应的键值对,注意这里的pop内的参数不能为空,因为没有顺序,不同于列表,列表是弹出最后一个 print(dic) #{'age': 20, 'name': 'jin', 'sex': 'male'}
dic.popitem() #随机删除一个键值对,返回元组,元组里保存删除键值对的键和值
k,v = dic.popitem #通过解构,将返回值 键放到k中,将值放到 v 中;字符串,列表,元组也可进行此操作,只是注意等号左边的变量要和右边的元素数一致
print(k)
print(v)
dic = {"name":"jin","age":18,"sex":"male"} dic2 = {"name":"alex","weight":75} dic2.update(dic) # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中 print(dic2) #{'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'} value1=dic["name"] #得到键name对应的值,没有报错 print(value1) #jin value2=dic.get("djdd","默认返回值") #得到键djdd对应的值,没有返回参数2 print(value2) #默认返回值 print(dic) item1 = dic.items() print(item1,type(item)) # dict_items([('name', 'jin'), ('sex', 'male'), ('age', 18)]) <class 'dict_items'> # 这个类型就是dict_items类型，可迭代的 同样的keys values也可以 key1 = dic.keys() #这里的item1 .key1. value1只是变量名 #dict_keys(['name', 'age', 'sex']) #可以把dic.keys()当做列表
for le in dic.keys():
print(le) #得到key
print(dic.get[le]) #得到key对应得value
value1 = dic.values() #dict_values(['jin', 18, 'male']) for key5 in dic.keys(): #遍历字典的key值,key5只是一个变量名 print(key5) for value in dic.values(): #遍历字典的value值,value亦只是个变量名 print(value) for item in dic.items(): #遍历字典的项元素 print(item) for key,value in dic.items(): print("key=%s,value=%s" % (key,value) )
可以认为key5 是所有键组成的列表,value是所有值组成的列表,item是键值对组成的列表,而其中的键值对是键和值组成的元组
for item in dic: # 直接循环迭代的时候拿到的是key
# 把第一个参数中的每一项拿出来和第二个参数组成一个键值对
# 生成出来的键指向的value是同一个对象. 改变其中一个的时候. 另一个也会跟着改变
#fromkeys是静态方法,返回字典但原字典不变
dic = dict.fromkeys(["jay", "jj"], ["周杰伦", "林俊杰"])
print(dic)
# {'jay': ['周杰伦', '林俊杰'], 'jj': ['周杰伦', '林俊杰']}
dic['jay'].append("蔡依林")
print(dic)
# {'jay': ['周杰伦', '林俊杰', '蔡依林'], 'jj': ['周杰伦', '林俊杰', '蔡依林']}
7. set {} 集合,一次存一个. 不能重复. 只存key, 比较少见
& 交集 | 并集 - 差集 ^反交集
#******************集合******************** #集合是无序的，不重复的数据集合 #它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点： #去重，把一个列表变成集合，就自动去重了。 #关系测试，测试两组数据之前的交集、差集、并集等关系 li=[1,1,2,2,"a"] #将列表变为集合,去重 set1=set(li) print(set1) #{'a', 1, 2} li.clear() li.extend(set1) #将去重后的集合变回成列表,当然顺序不可避免的改变了 set1=set({1,2,3} ) #创建集合的两种方法 ,可以使用set创建,也可以直接赋值 set2={1,2,3,4,5,6} set1.add("4") #增加 set1.update(["a","b","c"]) #迭代增加 #{1, 2, 3, '4', 'c', 'a', 'b'} set1.remove('a') # 删除一个元素 set1.pop() # 随机删除一个元素,因为是无序的所以随机删除 set1.clear() # 清空集合 print(set1) #set() del set1 # 删除集合 print(set1 < set2) #True print(set1.issubset(set2)) #set1是set2的子集 #True print(set2.issuperset(set1)) #set2是set1的超集 #True s=frozenset("barry") #frozenset不可变集合,让集合变为不可变类型 print(s,type(s)) #frozenset({'a', 'r', 'y', 'b'}) <class 'frozenset'> l1=[1,2,2,["barry","alex"]] l2=l1 l3=l1.copy() l1[1]=222 l1[3][1]="wusir" print(l1,id(l1)) #[1, 222, 2, ['barry', 'wusir']] 2275223314952 print(l2,id(l2)) #[1, 222, 2, ['barry', 'wusir']] 2275223314952 print(l3,id(l3)) #[1, 2, 2, ['barry', 'wusir']] 2275223317448 print(l1,id(l1[3][1])) #[1, 222, 2, ['barry', 'wusir']] 2275223306792 print(l3,id(l3[3][1])) #对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性 #[1, 2, 2, ['barry', 'wusir']] 2275223306792 import copy l4=copy.deepcopy(l1) #深拷贝deepcopy保证每层的copy地址都不同 l4[3][0]="wusir" print(l1,id(l1[3][0])) #[1, 222, 2, ['barry', 'wusir']] 2275223306288 print(l4,id(l4[3][0])) #[1, 222, 2, ['wusir', 'wusir']] 2275223306792
无论是深拷贝还是浅拷贝对于不可变的元素(整型,字符串,元组)其内存地址是一样的,直至在列表中替换这个元素,因为深拷贝的目的就是防止一个的操作对另一个复制品的值产生影响,而不可变量是不可变的,所以不会有影响
能转换成False的数据类型有哪些 0, '', [], (), {}, None, set(), False
浙公网安备 33010602011771号