python学习 day2

Posted 2020-11-01 飞奔的小水牛

1、str常用操作

1）字符串的索引与切片

 1 str1 = "python"
 2 >>> str1[0]   #截取第一个字符
 3 ‘p‘
 4 >>> str1[0:2] #截取0-1两个字符
 5 ‘py‘
 6 >>> str1[0:4:2]  #截取0-4之间的字符，且步长为2
 7 ‘pt‘
 8 >>> str1[-1:]  #截取最后一个字符
 9 ‘n‘
10 >>> str1[::-1]  #倒着截取字符串
11 ‘nohtyp‘

2）capitalize、swapcase、title

1 name = "hello World"
2 print(name.capitalize())    #首字母大写
3 print(name.swapcase())   #大小写反转
4 print(name.upper())   #将所有字符都换成大写
5 print(name.lower())   #将所有字符都换成小写
6 print(name.title())           #每个单词首字母大写

 

 

3）center

1 name = "hello world"
2 print(name.center(20,"+"))  #内容居中，指定左右间隔字符，同时可以指定以什么字符进行填充
3 
4 
5 输出：
6 ++++hello world+++++

4）count

1 name = "hello world"
2 print(name.count("l"))   #统计指定字符出现的次数
3 
4 
5 输出：
6 3

5）startswith、endswith

1 name = "hello world"
2 print(name.startswith("h"))  #是否以某个字符开头
3 print(name.endswith("d"))   #是否以某个字符结尾
4 
5 
6 输出：
7 True
8 True

6）find、index

1 name = "hello world"
2 print(name.find("h"))   #返回找到的元素索引，不存在返回-1
3 print(name.index("d")) #返回找到的元素索引，不存在会报错
4 
5 输出：
6 0
7 -1
8 10
9 ValueError: substring not found

7）split

1 name = "hello world"
2 print(name.split())   #指定分隔符，将分割的字符串制成列表，默认是以空格分割
3 print(name.split("o"))
4 
5 输出：
6 [‘hello‘, ‘world‘]
7 [‘hell‘, ‘ w‘, ‘rld‘]

8）format

 1 #format的三种玩法 格式化输出
 2 res1=‘{} {} {}‘.format(‘egon‘,18,‘male‘)
 3 res2=‘{1} {0} {1}‘.format(‘egon‘,18,‘male‘)
 4 res3=‘{name} {age} {sex}‘.format(sex=‘male‘,name=‘egon‘,age=18)
 5 print(res1)
 6 print(res2)
 7 print(res3)
 8 
 9 
10 输出：
11 
12 egon 18 male
13 18 egon 18
14 egon 18 male

9）strip

 1 name = "***hello world**"
 2 print(name.strip("*"))  #去除字符串左右的指定字符，默认是去除空格，经常是结合input使用
 3 print(name.lstrip("*"))  #去除字符串左边的指定字符
 4 print(name.rstrip("*"))  #去除字符串右边的指定字符
 5 
 6 
 7 输出：
 8 hello world
 9 hello world**
10 ***hello world

10）replace

 

1 name = "hello world"
2 print(name.replace("hello","你好"))  #替换字符串
3 
4 输出：
5 你好 world

11）is系列

 1 name1 = "hello1"
 2 name2 = "hello"
 3 name3 = "123"
 4 print(name1.isalnum())  #字符由字母或数字组成
 5 print(name2.isalpha())  #字符串由字母组成
 6 print(name3.isdigit())  #字符只由数字组成
 7 
 8 输出：
 9 True
10 True
11 True

 2、list

 

 1 #切片
 2 list1 = [1,2,"hello",3]
 3 print (list1[1])  #2
 4 print (list1[-1])  #3
 5 print (list1[:2])  #[1,2]
 6 print (list1[:3:2])  #[1, ‘hello‘]
 7 
 8 #增
 9 #append 在最后追加
10 list1.append(‘葫芦‘)
11 list1.append([1,2,3])
12 #insert插入
13 list1.insert(1,"world")
14 #迭代添加
15 list1.extend(‘Tom‘)
16 list1.extend(‘[111,222,333]‘)
17 
18 #删
19 #pop 有返回值  按照索引删除
20 print (list1.pop(0))
21 #remove  按照指定字符删除
22 print (list1.remove(‘hello‘))
23 #clear 清空列表
24 print (list1.clear())
25 #del 内存级别删除列表
26 del list1
27 del list1[1]  #索引删除
28 del list1[:3]  #切片删除
29 
30 #改
31 #按照索引修改
32 list1[2] = code
33 print (lit1)
34 #按照切片去修改
35 list1[:2] = ‘aaa‘
36 print (list1)
37 
38 #查
39 #按照索引去查询，按照切片去查询
40 for i in list1:
41     print(i)
42 #通过元素找索引
43 print (list1.index(2))
44 #sort 排序
45 list1.sort()   从小到大排序
46 list1.sort(reverse=True)  从大到小排序
47 #reverse  列表从右往左排序
48 list1.reverse()
49 
50 #列表嵌套
51 list2 = [1,2,‘abc‘,[‘name‘,‘age‘,123],‘qq‘]
52 #将abc全部变成大写，放回原处
53 list2[2] = ‘ABC‘
54 print (list[2].upper())
55 list2[2]  = list[2].upper()
56 #给[‘name‘,‘age‘,123]追加一个元素‘baidu’
57 list2[-2].append(‘baidu‘)
58 #将age首字母大写
59 list2[-2][1] = list2[-2][1].capitalize()
60 #将123通过数字相加，或者字符串相加变成150
61 list2[-2][-1] = str(list2[-2][-1] + 27)

 3、dict

 1     字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
 2 
 3     字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
 4 3.6版本之前，字典是无序的，3.6之后字典是有序的。
 5 dic = {"name":"Tom","age":18}
 6 
 7 字典的增:
 8 dic[‘li‘] = ["a","b","c"]   有则覆盖，无则添加
 9 print(dic)
10 # setdefault 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。
11 dic.setdefault(‘k‘,‘v‘)
12 print(dic)  # dic = {"name":"Tom","age":18,"k":"v"}
13 dic.setdefault(‘k‘,‘v1‘)  # {‘age‘: 18, ‘name‘: ‘jin‘, ‘sex‘: ‘male‘, ‘k‘: ‘v‘}
14 print(dic)
15 
16 字典的删：
17 print (dic.pop(‘name‘))  #返回删除key对应的value值
18 print (dic.pop(‘name1‘,‘没有此key‘))
19 print(dic)
20 dic.clear()  #清空
21 print (dic)
22 print(dic.popitem())  #随机删除，返回值删除的key，测试3.x版本是从后往前进行删除的，并不是随机删除
23 
24 字典的改：
25 dic[‘name‘] = ‘boy‘
26 print (dic)
27 dic = {"name":"Tom","age":18}
28 dic2 = {"name":boy","job":"IT"}
29 dic2.update(dic)   #将dic的键值对覆盖添加到dic2中，dic不变
30 
31 字典的查：
32 print (dic[‘name2‘])  #查找不存在的key会直接报错
33 print (dic.get(‘name2‘,‘此key不存在‘))  #可以自定义返回值
34 
35 
36 字典内置方法
37 #keys() values() items()
38 dic = {‘name‘: ‘jin‘, ‘age‘: 18, ‘sex‘: ‘male‘}
39 list(dic.keys())  #将key生成到一个列表中
40 for i in dic.keys():  #以列表返回一个字典所有的键
41     print (i)
42 for i in dic.values():  #以列表返回字典中的所有值
43     print (i)
44 for k,v in dic.items():   #以列表返回可遍历的(键, 值) 元组数组
45     print (k,v)
46 
47 分别赋值
48 a,b = 1,2
49 如何快速将两个变量值互换
50 a =1
51 b = 5
52 a,b = b,a
53 
54 fromkeys()  #创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
55 dic1 = dict.fromkeys(‘abc‘,[])
56 dic1[‘a‘].append(‘Tom‘)
57 print (‘dic1‘)

 4、小数据池，深浅copy

 1 #小数据池
 2 a = "Tom"
 3 b = "Tom"
 4 print (a == b)  #数值
 5 print (a is b)   #判断是否为同一个内存地址
 6 #python中是有小数据池的概念
 7 #int -5~256的相同的数全都指向一个内存地址，节省空间
 8 #str  s = ‘a‘ * 20以内都是同一个内存地址
 9 
10 #深浅copy
11 a = [1,2,3]
12 b = a   #b和a是共用一个内存地址，改变其中一个值，另外一个也会改变
13 a.append(666)
14 print (a,b)  #[1, 2, 3, 666] [1, 2, 3, 666]
15 
16 
17 #浅copy
18 l1 = [1,2,3]
19 l2 = l1.copy()
20 l1.append(666)
21 print (l1,l2)    #[1, 2, 3, 666] [1, 2, 3]
22 print (id(l1),id(l2))  #89582728 89581208  
23 
24 l1 = [1,2,3,[22,33]]
25 l2 = l1.copy()
26 l1[-1].append(666)
27 print(l1,l2)  #[1, 2, 3, [22, 33, 666]] [1, 2, 3, [22, 33, 666]]
28 print(id(l1[-1]),id(l2[-1]))  #89583208 89583208
29 对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。
30 
31 #深copy   对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变
32 import copy
33 l1 = [1,2,3,[22,33]]
34 l2 = copy.deepcopy(l1)
35 l1[-1].append(666)
36 print(l1,l2)
37 print(id(l1[-1]),id(l2[-1]))

5、数据类型补充

注意：

1、在循环一个列表时，不要对列表进行删除的动作(改变列表元素的个数动作)，删除一个数据时，再次循环时数据索引会改变

2、dict 再循环字典时，不要改变字典的大小，删除数据会报错

3、如果元组里面只有一个元素并且没有逗号隔开，那么他的数据类型与该元素一致

1 >>> tu1 = (1)
2 >>> type(tu1)
3 <class ‘int‘>
4 >>> tu2 = (1,)
5 >>> type(tu2)
6 <class ‘tuple‘>

 

运算符	表达式	说明
and	a and b	逻辑与，当a为True时才计算b
or	a or b	逻辑或，当a为False时才计算b
not	not a	逻辑非

 

非零为true，无论正负

1、 and    与     a  and  b       a为true则计算b，否则返回false

2、 or       或     a  or  b         a为false则计算b，否则返回true

3、 not     非                          加not取反