首页 > 其他分享> 文章详细

小螺丝的学习笔记day13(第二周总结)——容器型数据类型总结

2021-08-01 19:05:30 阅读：184 来源： 互联网

标签：总结 apple 数据类型列表字符串 set1 day13 print True

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 orange

1.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)        # True

1.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 (