1 列表(list)——可变数据类型
1.1创建方式
创建方式1字面量语法：list1 = [ 'apple', 'orange' ]
创建方式2构造器语法： list2 = list ( range(1, 10))
创建方式3生成式(推导式)语法：list3 = [ i ** 2 for i in range(1, 10) ]
1.2遍历列表中的元素
如：list1 = [ 'apple', 'orange' ]
# 遍历方式1：
for i in range(len(list1)):
print(list[i]) # list[0] list[1]
# 遍历方式2：
for x in list1:
print(x) # apple orange
# 遍历方式3：既可以获取到索引（下标）又可以获取到元素
for i, x in enumerate(list1):
print(i, x) # 0 apple 1 orange1.3列表的运算
1、列表的重复：list4 = [ 1, 10, 100 ] * 5
2、成员运算：print( 10 in list4 ) # True
3、列表的拼接：temp = list5+ list6
4、列表的索引：print ( list4 [ 2 ] , list4 [ -3 ] ) # 打印列表中第2和第-3( 即右数 )个数：100，1
5、列表的切片：
nums=[35,12,97,55,68,73,49,90,20]
print(nums[2:]) # 从第三个开始
print(nums[:]) # 与原来一样
print(nums[::-1]) # 反转全取
print(nums[1:3]) # 取第二个及第三个
print(nums[2:7:2]) # 取第三个到第7个之间，步长2
print(nums[10:15]) # 超出范围，空列表
print(nums[5:1]) # 前大后小，空列表（若加负数步长就不是空列表了）6、获取列表的长度：print ( len ( list4 ) ) # 通过len 函数
7、列表的比较：要相同类型，比如不能整型与字符串进行比较
list7 = list(range(1, 8, 2))
list8 = [1, 3, 5, 7, 9]
#比较两个元素是否一一相等
print(list8==list7) # False
#比较两个列表的对应元素的大小：不看元素多少，从第一个元素开始一一比大小
print(list7<list8) # True1.4 列表的方法
如：items=[ 'b' , 'g' , 'a' , 'w' , 'p' , 'a' ]
1、查找元素的位置：index()---->查找元素在列表中的索引（下标） index()
if 'b' in items:
print(items.index('b'))2、统计元素在列表中出现的次---->count( )：print ( items.count ( 'a' ) ) count()
3、添加元素：
items.append ( 'b' ) # append 在列表尾部增加元素 append()
items.insert ( 1, 's' ) # insert 在指定位置增加元素 insert()
4、删除元素：
items.pop( ) # pop 删除最后一个 pop()
items.pop( 4 ) # pop(i) 删除指定索引位置元素 pop(i)
items.remove( 'a' ) # remove指定删除的那个，若有重复的，删的是第一个 remove()
5、清空元素：items.clear( ) clear()
6、反转和排序：
items.reverse( ) # 反转 reverse()
items.sort( ) # 升序 ( 若元素是整数的字符串可以用 sort ( key = int ) ) sort()
items.sort( reverse=True ) # 降序(可以修改reverse参数控制升序或降序) sort(reverse=True)
列表的嵌套——见《小螺丝的Python学习笔记day09——列表嵌套&元组》https://blog.csdn.net/wwd2021/article/details/119149369?spm=1001.2014.3001.5501
2 元组(tuple)——不可变数据类型
2.1元组的创建：
定义元组通常使用字面量语法：fruits1=( ' apple ' , ' banana ' , ' orange ' )
注意：一元组必须有 “，”，如若( ' hello ' )与(100)，无逗号则变成了字符串和整数，( ' hello '， )与(100，)才是一元组。
2.2遍历元组中的元素
for x in fruits1:
print ( x ) # apple banana orange
2.3元组的运算及方法
1、重复运算：fruits = fruits1*3
2、成员运算：print ( ' apple ' in fruits1 ) # True
3、合并：fruits2 = ( ' grape ' , ' litchi ' ) fruits1=( ' apple ' , ' banana ' , ' orange ' )
fruits3 = fruits1 + fruits2
4、索引和切片：
通过索引运算获取元组中的元素：print ( fruits3 [ 4 ] , fruits3 [ -1 ] ) # litchi litchi
print ( fruits3 [ ::-1 ] ) # ( ' litchi ' , ' grape ' , ' orange ' , ' banana ' , ' apple ' )
print ( fruits3 [ ::2 ] ) # ( ' apple ' , ' orange ' , ' litchi ' )
print ( fruits3.index ( ' apple ' ) ) # 0
print ( fruits3.count ( ' apple ' ) ) # 1
5、比较运算：
print ( fruits1 == fruits3 ) # False
print ( fruits1 < fruits3 ) # True
2.4元组的应用
1、打包
a, b, *c = 5, 10, 15, 20, 25
print ( a ) / print ( b ) / print ( c ) # 5 / 10 / [15, 20, 25]
2、解包：
i , j , k = c
print ( i , j , k ) # 15 20 25
3、交换两个变量的值：a , b = b , a
4、Python中元组和列表的相互转化：
将元组转换成列表：list() list()
info = ( ' 骆* ' , 175 , True , ' 四川成都 ' )
print ( list ( info ) ) # [ ' 骆* ' , 175 , True , '四 川成都 ' ]
将列表转换成元组：tuple() tuple()
fruits = [ ' apple ' , ' banana ' , ' orange ' ]
print ( tuple ( fruits ) ) # ( ' apple ' , ' banana ' , ' orange ' )
3 字符串(string)——不可变数据类型
3.1字符串的创建
字面量语法：a = ' hello , world ' ， b= " hello , World " ，常用单引号 or 双引号
3.2 循环遍历每个字符
遍历方式1：for i in range(len(a)): ----> print(a[i])
遍历方式2：for i in a: ----> print(i)
3.3 字符串的运算
1、重复运算：print ( a * 5 )
2、成员运算：print ( 'or ' in a ) # True
3、字符串的拼接：d = ' hello , everybody ' ， e = ' ! ! ! ' print ( d + e )
4、索引和切片：a = ' hello , world '
print ( a [ len ( a ) - 1 ] , a [ -1 ] ) # d d
print ( a [ 1:10:2 ] ) # el , wr
print ( a [ ::-1 ] ) # dlrow ,olleh （反转）
5、比较运算：print ( a != b ) # True
c = ' goodbye , world '
print ( b > c ) # True ( 比较字母的顺序 )
6、获取字符串的长度：len ( ) 函数
3.4字符串的相关操作
3.4.1转义字符和原始字符
字符串中使用\（反斜杠）来表示转义，比如：\n不是代表反斜杠和字符n，而是表示换行；\t也不是代表反斜杠和字符t，而是表示制表符。
例如：s1 = ' \ time up \ now ' # 字符串s1中\t是制表符，\n是换行符
原始字符串，每个字符都是它原始的含义，没有转移字符，Python中的字符串可以r或R开头。
s2 = r ' \ time up \ now ' R 或 r
print ( s2 ) # \ time up \ now
3.4.2 大小写相关操作
a = i LOVE you
print ( a.upper ( ) ) # I LOVE YOU upper 全部大写 upper()
print ( a.lower ( ) ) # i love you lower 全部小写 lower()
print ( a.capitalize ( ) ) # I love you capitalize 首字母大写 capitalize()
print ( a.title ( ) ) # I Love You title 每个单词首字母大写 title()
3.4.3 性质判断
b = ' abc123 '
print ( b.isdigit ( ) ) # False isdigit 判断字符串是不是数字 isdigit()
print ( b.isalpha ( ) ) # False isalpha 判断字符串是不是字母 isalpha()
print ( b.isalnum ( ) ) # True isalnum 判断字符串是不是字母和数字 isalnum()
print ( b.isascii ( ) ) # True isascii 判断字符串是不是ASII码字符 isascii()
print ( c.startswith ( ' a ') ) # True startwith 判断字符串是否以指定内容开头 startwith()
print ( c.endswith ( ' 2 ' ) ) # False endswith 判断字符串是否以指定内容结尾 endswith()
3.4.4 查找操作
在一个字符串中从前向后查找有没有另外一个字符串，可以使用字符串的find或index方法。
a = ' Oh apple, i love apple.'
index - 从左向右寻找指定的子串 (substring)，可以指定从哪开始找，默认是0；找到了返回子串对应的索引（下标），找不到直接报错（程序崩溃）
print ( a.index ( ' apple ' ) ) # 3 index()
print ( a.index ( ' apple ', 10 ) ) # 17
rindex -从右向左找，找到了返回子串对应的索引(下标，此标也是从左到右数的)，找不到直接报错（程序崩溃）
print ( a.rindex ( ' apple ' ) ) # 17 rindex()
print ( a.index ( ' banana ' ) ) # 保错 ValueError: substring not found
与index 不同的是 find 找不到直接报时输出 -1
print ( a.find ( ' banana ' ) ) # -1 find()
print ( a.rfind ( ' banana ' ) ) # -1 rfind()
3.4.5 格式化字符串
python中居中、左对齐和右对齐的处理 ：
a = ' hello,word '
print ( a.center ( 20 , '~' ) ) # ~~~~~hello,word~~~~~ 居中 center()
print ( a.rjust ( 20 , '~' ) ) # ~~~~~~~~~~hello,word 右对齐 rjust()
print ( a.ljust ( 20 , '~' ) ) # hello,word~~~~~~~~~~ 左对齐 ljust
b = ' 123 '
print ( b.zfill ( 6 ) ) # 000123 零填充(在左边补零) zfill()
字符串的格式化输出
c = 1234 d = 123
方式1： print ( ' % d + % d = % d ' % ( c , d, c + d , ) )
方式2：Python3.6以后引入的格式化字符串便捷语法 print ( f ' { c } + { d } = { c + d } ' )
方式3：print ( ' { } + { } = { } ' .format ( c , d , c + d ) ) format()
方式4：print ( ' { 0 } + { 1 } = { 2 } '.format ( c , d , c + d ) ) (注：0，1，2占位用的)
若需进一步控制格式化语法中变量值的形式，可以参照下面的表格来进行字符串格式化操作 。
3.4.6 字符串的修剪
content = ' 马某某是个二货 '
print ( content.strip ( ) ) strip 修剪字符串左右两端的空格 strip()
print ( content.lstrip ( ) ) lstrip 修剪字符串左端的空格 lstrip()
print ( content.rstrip ( ) ) rstrip 修剪字符串右端的空格 rstrip()
3.4.7 字符串的替换
replace把里面的字符串替换为其他的 replace()
content1 = ' 马某某是个* '
print ( content1. replace ( ' 马 ' , ' * ' ) ) # * 某某是个 *
3.4.8 字符串的拆分与合并
拆分：split 函数 split()
content = ' you go your way , I will go mine .'
content2 = ' you go your way I will go mine '
items = content.split ( ',' ) # you go your way I will go mine 用逗号拆分字符串
words = content2.split ( ) # 用空格拆分字符串得到一个列表
words = content2.split (' ', maxsplit = 3 ) # 用空格拆分字符串，最多允许拆分3次
words = content2.rsplit (' ', maxsplit = 3 ) # 从有向左进行字符串拆分，最多允许拆分3次
合并：join 函数 join()
contents = [ ' 请不要相信我的美丽 ' , ' 更不要相信我的爱情 ' ]
print ( ' '.join ( contents ) ) # 表示将列表中的元素用指定的字符串连接起来，此处所用空格
3.4.9 字符串的编码和解码
两种方式： str(字符串)--->encode()--->bytes(字节串) encode()
bytes(字节串)--->decode()--->str(字符串) decode()
要点：
1、选择字符集(编码)的时候，最佳的选择(也是默认的)是UTF-8编码。
2、编码和解码的字符集要保持一致，否则就会出现乱码现象。
3、不能用ISO-8859-1编码保存中文，否则就会出现编码黑洞，中文变成?
4、UTF-8是Unicode的一种实现方案,也一种变长的编码,最少1个字节(英文和数字),最 多 4个字节（Emoji），表示中文用3个字节。
4 集合(set)——可变数据类型
4.1 集合的创建
集合(set)的定义是把一定范围的、确定的、可以区别的事物当作一个整体来看待”，集合中的各个事物通常称为集合的元素。集合具有无序性、互异性、确定性。因此，Python中的集合肯定不能够支持索引运算，集合的互异性决定了集合中不能有重复元素。
集合的创建方式1字面量语法：set1 = { 1,1,2,3,1,1,2 }
集合的创建方式2构造器语法：set2 = set ( ' hello ' )
集合的创建方式3生成式语法：set3 = { num for num in range ( 1, 20 ) if num % 3 == 0 }
特别强调空集合：set5=set( )
print ( type(set5 ) ) # < class ' set ' >
print ( set5 ) # set ( )
4.2 遍历集合中的元素
for elem in set1:
print ( elem ) # 1 2 3
4.3 集合的运算
4.3.1 成员运算
set1 = { 1, 2, 3, 4, 5 } set2 = { 2, 4, 6, 8 }
print ( 1 in set1 ) # True
4.3.2 交并运算
交集：print ( set1 & set2 ) # { 2, 4 }
print ( set1.intersection ( set2 ) ) # { 2, 4 } intersection()
并集：print ( set1 | set2 ) # {1, 2, 3, 4, 5, 6, 8}
print ( set1.union ( set2 ) ) # {1, 2, 3, 4, 5, 6, 8} union()
差集：print ( set1 - set2 ) # {1, 3, 5}
print ( set1.difference ( set2 ) ) # {1, 3, 5} difference()
print ( set2 - set1 ) # {8, 6}
print ( set2.difference ( set1 ) ) # {8, 6}
对称集：(并集-交集)
print ( set1 ^ set2 ) # {1, 3, 5, 6, 8}
print ( ( set1 | set2 ) - ( set1 & set2 ) ) # {1, 3, 5, 6, 8}
4.2.3 比较运算
set3 = { 1,2,3,4,5,6,7,8,9 }
print ( set1 < set3 ) # True 判断真子集
print ( set1 <= set3 ) # True 判断子集
print ( set3 > set2 ) # True 判断超集
4.3 集合的操作
set1 = { 'apple','banana','pitaya','apple' }
set1.add ( 'grape' ) add 添加元素 add()
set1.discard ( 'pitaya' ) discar 指定元素删除 discar()
set1.pop( ) pop 随机删除 pop()
set1.clear( ) clear 清空元素 clear()
5 字典(dict)——可变数据类型
5.1 字典的创建
字典以键值对（键和值的组合）的方式把数据组织到一起，我们可以通过键找到与之对应的值并进行操作 。
字典的创建方式1字面量语法：
student1={
'id':1001,
'name':'骆昊',
'sex':'True',
'birthday':'1980-11',
'contacts':{
'QQ':'4625900568',
'tel':'135673542'
}
}
print ( student1 [ ' contacts ' ] [ ' tel ' ] ) # 135673542
字典的创建方式2构造器函数：
student2 = dict ( id = 1001 , name = ' 王大锤 ' , sex = True , birthday = ' 1980-11 ' )
字典的创建方式1生成式语法：dict1 = { i: i**2 for i in range ( 1,10 ) }
5.2 遍历字典
1、遍历字典中的健：
# for key in student1:
for key in student1.keys( ):
print ( key ) # id name sex birthday contacts
2、遍历字典中的值：
for value in student1.values( ):
print(value) # 1001 骆昊 True 1980-11 {'QQ': '4625900568', 'tel': '135673542'}
3、遍历字典中的健值对---> (key, value)
for key,value in student1.items( ):
print ( key,value )
5.3 字典的运算
1、成员运算：print ( ' name ' in student2 ) # True
2、字典的索引运算放在赋值运算的左边，如果索引对应的健是存在的，就更新它的值
student2 [ 'name ' ] = ' 汪美丽 '
print ( student2 ) # { 'id': 1001, 'name': '汪美丽', 'sex': True, 'birthday': '1990-11' }
如果字典中没有对应的索引，就增加一组新的"键值对"
student2 [ 'address' ] = ' 四川成都 '
print (student2) # {'id': 1001, 'name': '汪美丽', 'sex': True, 'birthday': '1990-11', 'address': '四川成都'}
3、通过id修将student字典中对应的值修改为2110
if 'id' in student:
student [ 'id' ] = 2110
4、对字典的键进行循环并通索引运算获取键对应的值
for key in student:
print ( f ' {key}: {student [ key ] } ' )
5.4 字典的相关操作
1、get函数获取value get()
使用get函数通过key获取value时，如果key不存在，不会发生KeyError错误；而是得到一个None(空值)或者是你指定的默认值。
print ( student.get ( 'age ' ) ) # None
print ( student.get ( 'age',20 ) ) # 20
print ( student.get ( 'name','无名氏' ) ) # 汪美丽 (因有name且是'汪美丽'，若无'name'则为'无名氏')
2、更新(元素的合并或更新)
dict1 = { 'a':'100','b':200,'c':300 } dict2 = { 'd':'400','e':500,'a':600 }
dict1.update ( dict2 ) update()
print ( dict1 ) # { 'a': 600, 'b': 200, 'c': 300, 'd': '400', 'e': 500 }
3、删除(键必须存在，如果不存在会产生KeyError)
del dict1[ 'b' ] # 指定删除 del
dict1.pop ( 'b' ) # 指定删除 pop( 'i' )
dict1.popitem() # 删除最后一个键值对 popitem()
print ( dict1) # {'a': 600, 'c': 300, 'd': '400'}
4、setdefault 可以输出字典中的键对应的值或向字典中存入新的键值对 setdefault()
print ( dict1.setdefault ('c') ) # 300
print ( dict1.setdefault ( 'k', 10000 ) ) # 10000(字典中没有键值对时，输出新的指定值)
print ( dict1 ) # { 'a': 600, 'c': 300, 'd': '400', 'k': 10000 }
5、清空所有clear claer()
dict1.clear()
print (dict1) # { }
6、 字典中健与值互换 zip zip()
dict1 = { 'A': 1, 'B': 2, 'C': 3, 'D': 4 } dict2 = dict ( zip(dict1.values( ), dict1.keys( ) ) )
print ( dict2 ) # {1: 'A', 2: 'B', 3: 'C', 4: 'D'}
7、Josn格式数据----->字典
loads函数可以将JSON格式的数据转成Python中字典 json.loads()
date = """{
"code":200,
......
}
news_dict = json.loads ( data )
互联网获取josn格式数据并解析： josn()
resp = requests.get (
......
)
weather_dict=resp.json()