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

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中的字符串可以rR开头。

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 查找操作

在一个字符串中从前向后查找有没有另外一个字符串,可以使用字符串的findindex方法。

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占位用的)

若需进一步控制格式化语法中变量值的形式,可以参照下面的表格来进行字符串格式化操作 。

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

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()

上一篇:CGB2104-Day13


下一篇:linux学习day13笔记