python基础----04-----函数、数据容器(列表list、元祖tuple、字符串str、集合set、字典dict，包括容器序列的切片操作)、容器之间的转换、容器sorted排序、字符串大小比

最新推荐文章于 2024-07-22 22:58:19 发布

Mango酱

最新推荐文章于 2024-07-22 22:58:19 发布

阅读量129

点赞数

分类专栏： python学习文章标签： python list 开发语言

本文链接：https://blog.csdn.net/weixin_44517656/article/details/131015350

版权

python学习专栏收录该内容

11 篇文章 5 订阅

订阅专栏

一函数的基本定义语法

函数的定义：

 def 函数名 (传入参数):
     函数体
     return 返回值  #其中传入参数与返回值可以没有

函数的调用：

 # 传入参数可以是空，或者是一个到多个
 a = 函数名(传入参数)

例如。

if __name__ == '__main__':
    def check():
        print("你好")
    # 函数调用
    check()
    """
    你好
    """

二函数的返回值定义语法

if __name__ == '__main__':
    def add(a,b):
        result = a + b
        return result
    r = add(1,2)
    print(r)
    """
    3
    """

如果函数没有使用return语句返回数据，那么函数有返回值吗?
实际上是：有的。

Python中有一个特殊的字面量: None, 其类型是: <class ‘NoneType’>
无返回值的函数，实际上就是返回了： None这个字面量。

if __name__ == '__main__':
    def add(a, b):
        result = a + b
       
    r = add(1, 2)
    print(type(r)) #<class 'NoneType'>

None作为一个特殊的字面量，用于表示:空、无意义，其有非常多的应用场景。

用在函数无返回值上。
用在if判断上。
在if判断中，None等同于False，一般用于在函数中主动返回None，配合if判断做相关处理。
用于声明无内容的变量上。定义变量，但暂时不需要变量有具体值，可以用None来代替。

if __name__ == '__main__':
    # 主动返回None的函数
    def say_hi2():
        print("你好呀")
        return None
    result = say_hi2()
    print(f"无返回值函数，返回的内容是: {result}")
    print(f"无返回值函数，返回的内容类型是: {type(result)}")

    # None用于if判断
    def check_age(age):
        if age > 18:
            return " SUCCESS"
        else:
            return None
    result=check_age(16)
    if not result:
        # 进入if表示result是None值也就是False
        print("未成年，不可以进入")

    """
    你好呀
    无返回值函数，返回的内容是: None
    无返回值函数，返回的内容类型是: <class 'NoneType'>
    未成年，不可以进入
    """

if __name__ == '__main__':
   name = None

三变量在函数中的作用域

变量作用域指的是变量的作用范围(变量在哪里可用，在哪里不可用)。
主要分为两类：局部变量和全局变量，

局部变量的作用：在函数体内部，函数调用完之后临时变量立即消失（前面讨论if for while 中定义的变量时外部可以访问但是不推荐那样用函数是出错不可以外面调用局部变量）。

if __name__ == '__main__':
    def testA():
        num = 100
        print(num)
    testA() # 100
    print(num)# 报错: name    'num  is not defined'

在这里插入图片描述

全局变量：指的是在函数体内、外都能生效的变量。

if __name__ == '__main__':
    num = 100
    def testA():
        print(num)
    testA() # 100
    print(num)# 100

在这里插入图片描述

可以通过global声明或者定义全局变量。
没有global声明，由于作用域不同，所以在testA()函数内部修改num=200，无法影响到函数外的值。

if __name__ == '__main__':
    num = 100
    def testA():
        num = 200
        print(num)

    testA()
    print(num)

在这里插入图片描述

若想在testA()声明为全局变量，此时可以加上global声明：

if __name__ == '__main__':
    num = 100
    def testA():
        global num
        num = 200
        print(num)

    testA()
    print(num)

在这里插入图片描述

注意，如果我们把最开头的num = 100去掉，在testA()内部加上global关键字，此时也是全局变量。

if __name__ == '__main__':
    def testA():
        global num
        num = 200
        print(num)

    testA()
    print(num)

在这里插入图片描述

四数据容器入门

python数据容器主要分为5类，分别是：列表(list) 、元组(tuple) 、字符串(str) 、集合(set) 、字典(dict)。

4.1 列表

4.1.1 列表的定义语法

#字面量
[元素1，元素2，元素3...]

#定义变量
变量名称 = [元素1，元素2，元素3...]

#定义空列表
变量名称 = []
变量名称 = list()

列表内的每一个数据，称之为元素。

以[ ]作为标识。
列表内每一个元素之间用，逗号隔开。
注意：列表可以存储一次存储多个数据，且可以为不同的数据类型，支持嵌套。

if __name__ == '__main__':
    my_list = ["who", "are", "you"]
    print(my_list)
    print(type(my_list))

    my_list = [" who", 666, True]
    print(my_list)
    print(type(my_list))

在这里插入图片描述

列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增；或者从后向前，从-1开始，依次递减。

if __name__ == '__main__':
    # 定义一个嵌套的列表
    my_list = [1, 2, 3]
    print(my_list[0], my_list[1], my_list[2])
    print(my_list[-3], my_list[-2], my_list[-1])

在这里插入图片描述

4.1.2 列表的常用操作方法

列表除了定义、使用下标索引，以外也提供了一系列功能：插入元素、删除元素、清空元素、修改元素、统计元素个数等等功能，我们成为列表的方法。

函数是一个封装的代码单元，可以提供特定功能。在python中，如果将函数定义为class（类）的成员，那么函数会称为：方法。

# 函数
def add(x, y):
    return x + y


# 方法
class Student:
    def add(self, x, y):
        return x + y

方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同：
函数的使用：

num= add(1,2)

方法的使用：

student = Student() 
num = student.add(1,2)

4.1.2.1 列表的查询功能

语法：列表.index(元素)
功能：查找指定元素在列表的下标，如果找不到，报错ValueError。
index就是列表对象(变量)内置的方法(函数)。

if __name__ == '__main__':
    my_list = [" itheima", 666, True]
    print(my_list.index(" itheima"))
    my_list = [[1, 2, 3], [4, 5, 6]]
    print(my_list.index(1))   #报错！！！
    print(my_list.index([1, 2, 3]))  # 0

在这里插入图片描述

4.1.2.2 列表的修改

语法：列表[下标]=值

if __name__ == '__main__':
    # 正向下标
    my_list = [1,2,3]
    my_list[0] = 5
    print(my_list)    # 结果:    [5，2，3]
    # 反向下标
    my_list = [1,2,3]
    my_list[-3] = 5
    print(my_list)    # 结果:    [5，2, 3]

4.1.2.3 列表的插入

语法：列表.insert（下标，元素），在指定的下标位置，插入指定的元素。

if __name__ == '__main__':
    my_list = [1, 2, 3]
    my_list.insert(1, "itheima")
    print(my_list)
    '''
    [1, 'itheima', 2, 3]
    '''

4.1.2.4 列表的追加

语法：列表.append（元素），在指定元素，追加到列表的尾部。

if __name__ == '__main__':
    my_list = [1, 2, 3]
    print(my_list)
    my_list.append(4)
    print(my_list)
    # 结果:
    '''
    [1, 2, 3]
    [1, 2, 3, 4]
    '''

4.1.2.5 列表的extend用法

extend可以一次往列表添加多个元素。

if __name__ == '__main__':
    my_list = [1, 2, 3]
    my_list.extend([4, 5, 6])
    print(my_list)
    # 结果:
    '''
    [1, 2, 3, 4, 5, 6]
    '''

if __name__ == '__main__':
    my_list = [1, 2, 3]
    my_list.extend(["who", "are", True])
    print(my_list)
    # 结果:
    '''
    [1, 2, 3, 'who', 'are', True]
    '''

4.1.2.6 列表的删除

列表的删除有3种方式。

语法1：del 列表[下标]。
语法2：列表.pop(下标)。
语法3：列表.remove(元素)。注意，remove函数传的是元素，并非是下标。

if __name__ == '__main__':
    my_list = [1, 2, 3]
    print(my_list)
    del my_list[1]
    print(my_list)

    my_list.pop(1)
    print(my_list)
    # 结果:
    '''
    [1, 2, 3]
    [1, 3]
    [1]
    '''

列表.remove测试。

if __name__ == '__main__':
    my_list = [1, 2, 3]
    print(my_list)
    my_list.remove(2)
    print(my_list)
    my_list.remove(2) # 删除不存在的元素会报错
    print(my_list)
    # 结果:
    '''
    [1, 2, 3]
    [1, 3]
    '''

在这里插入图片描述

4.1.2.7 清空列表

语法：列表.clear()。

if __name__ == '__main__':
    my_list = [1,2,3]
    print(my_list)
    my_list.clear()
    print(my_list)
    # 结果:
    '''
    [1, 2, 3]
    []
    '''

4.1.2.8 列表统计某个元素个数

语法：列表.count(元素)。

if __name__ == '__main__':
    my_list = [1, 2, 3, 3, 3, 3, 5]
    print(my_list)
    count = my_list.count(3)
    print(count)
    # 结果:
    '''
    [1, 2, 3, 3, 3, 3, 5]
    4
    '''

4.1.2.9 统计全部元素个数(长度)

语法：len(列表)。

if __name__ == '__main__':

    my_list = [1, 2, 3, 3, 3, 3, 5]
    print(my_list)
    count = len(my_list)
    print(count)

    # 结果:

    '''
    [1, 2, 3, 3, 3, 3, 5]
    7
    '''

在这里插入图片描述

4.1.3 列表总结

经过上述对列表的学习，可以总结出列表有如下特点：
●可以容纳多个元素(上限为2**63+1、9223372036854775807个)。
●可以容纳不同类型的元素(混装)。
●数据是有序存储的 (有下标序号)。
●允许重复数据存在。
●可以修改(增加或删除元素等)。

4.1.4 列表的循环遍历

while循环。
定义一个变量表示下标，从0开始。
循环条件：下标值 < 列表的元素数量。

if __name__ == '__main__':

    my_list = [21,25,21,23,22,20]
    index = 0
    while index < len(my_list):
        print(my_list[index], end=" ")
        index +=1
    print()
    print(my_list)

在这里插入图片描述
for循环。
语法：

'''
for 临时变量 in 数据容器：
    对临时变量进行处理
'''

表示，从容器内，依次取出元素并赋值到临时变量上。
在每一次的循环中，我们可以对临时变量(元素)进行处理。

if __name__ == '__main__':
    my_list = [21,25,21,23,22,20]
    index = 0
    for a in my_list:
        print(a ,end=" ")
    print()
    print(my_list)

在这里插入图片描述

while与for的对比，while循环和for循环，都是循环语句，但细节不同：

在循环控制上：

1）while循环可以自定循环条件，并自行控制。
2）for循环不可以自定循环条件，只可以一个个从容器内取出数据。

在无限循环上：

1）while循环可以通过条件控制做到无限循环。
2）for循环理论上不可以，因为被遍历的容器容量不是无限的。

在使用场景上：

1）while循环适用于任何想要循环的场景。
2）for循环适用于，遍历数据容器的场景或简单的固定次数循环场景。

4.2 元组的定义和操作

4.2.1 元祖的定义

为什么要引入元组？
思考列表的痛点，他可以被修改，我们有时候需要我自己封装的程序数据不被修改，那么我们就引入了元组——一旦完成定义，就不可以修改。他同样可以储存不同类型元素。
在这里插入图片描述

if __name__ == '__main__':
    # 定义元组
    t1 = (1, "Hello", True)
    t2 = ()
    t3 = tuple()
    print(f"t1的类型是: {type(t1)}， 内容是: {t1}")
    print(f"t2的类型是: {type(t2)}， 内容是: {t2}")
    print(f"t3的类型是: {type(t3)}， 内容是: {t3}")

    '''
    t1的类型是: <class 'tuple'>， 内容是: (1, 'Hello', True)
    t2的类型是: <class 'tuple'>， 内容是: ()
    t3的类型是: <class 'tuple'>， 内容是: ()
    '''

但是定义单个变量时！！！！一个元素后面加上逗号","，这是为了防止和字符串发生二义。

if __name__ == '__main__':
    # 定义元组
    t1 = ("Hello",)

    # 单个元素不加逗号，类型是字符串
    t2 = ("Hello")

    print(f"t1的类型是: {type(t1)}， 内容是: {t1}")
    print(f"t2的类型是: {type(t2)}， 内容是: {t2}")

    '''
    t1的类型是: <class 'tuple'>， 内容是: ('Hello',)
    t2的类型是: <class 'str'>， 内容是: Hello
    '''

在这里插入图片描述

同样元组可以嵌套使用。

if __name__ == '__main__':
    # 元组的嵌套
    t5 = ((1, 2, 3), (4, 5, 6))
    print(f"t5的类型是: {type(t5)}， 内容是: {t5}")

    '''
    t5的类型是: <class 'tuple'>， 内容是: ((1, 2, 3), (4, 5, 6))
    '''

4.2.2 元祖的操作

元祖的操作方法。
在这里插入图片描述

if __name__ == '__main__':
    # 1. 元组支持下标索引
    t5 = ((1, 2, 3), (4, 5, 6))
    num = t5[1][2]
    print(f"t5的取出的内容是: {num}")  # 6

    # 2. 根据index()，查找特定元素的第一个匹配项
    t1 = (1, 2, 'hello', 3, 4, 'hello')
    print(t1.index('hello'))  # 结果:2

    # 3. 统计某个数据在元组内出现的次数
    t1 = (1, 2, 'hello', 3, 4, 'hello')
    print(t1.count('hello'))  # 结果: 2

    # 4. 统计元组内的元素个数
    t1 = (1, 2, 3)
    print(len(t1))  # 结果3

在这里插入图片描述

元组的遍历。

if __name__ == '__main__':

    t1 = ("h", 1, 4.2, True)
    index = 0
    while index < len(t1):
        print(f"元组的元素有: {t1[index]}")
        # 至关重要
        index += 1

    # 元组的遍历: for
    for eLement in t1:
        print(f"2元组的元素有: {eLement}")

在这里插入图片描述

如果尝试修改tuple中的数据：
错误提示：TypeError: ’ tuple 'object does not support item assignment
但是如果你元组中嵌套了一个list，它就可以改list里面的东西。

if __name__ == '__main__':
    # 尝试修改元组内容
    t1 = (1, 2, ['itheima', 'itcast'])
    t1[2][1] = ' best'	# 列表可以修改
    print(t1)# 结果:(1, 2, ['itheima', ' best'])
    t1[0] = 10 # 报错，除了元祖的元素是列表以外，其它类型无法修改

在这里插入图片描述

4.2.3 元祖的总结

在这里插入图片描述

4.3 字符串的定义和操作

字符串是字符的容器，一个字符串可以存放任意数量的字符。
在这里插入图片描述
和其它容器如:列表、元组一样，字符串也可以通过下标进行访问。

从前向后，下标从0开始。
从后向前，下标从-1开始。

1. 字符串的下标（索引）

if __name__ == '__main__':
    t1 = "who are you"
    print(t1[2])# o
    print(t1.index("h")) # 1

2. 字符串无法修改
1）无法修改指定下标的字符(如:字符串[0]=“a" )
2）无法移除特定下标的字符(如: del 字符串[0]、字符串.remove()、字符串.pop()等)
3）无法追加字符等(如:字符串.append())
这些都是无法完成的，除非重新定义另一个字符串才可以。
如果修改会发生错误：TypeError: ‘str’ object does not support item assignment。

if __name__ == '__main__':
    t1 = "who are you"
    t1[0] = '1'

在这里插入图片描述

3. 字符串的替换

语法：字符串.replace(字符串1,字符串2)
功能：将字符串内的全部字符串1，替换为字符串2
注意：不是修改字符串本身，而是得到了一个新字符串

if __name__ == '__main__':
    t1 = "(1,2,['itheima', 'itcast'])"
    t2 = t1.replace(',', "sb")
    print(t2)

结果。
在这里插入图片描述

4. 字符串的分割

语法:字符串.split(分隔符字符串)
功能:按照指定的分隔符字符串,将字符串划分为多个字符串，并存入列表对象中
注意:字符串本身不变，而是得到了一个列表对象

if __name__ == '__main__':
    t1 = "(1,2,['itheima', 'itcast'])"
    t2 = t1.split(',')
    print(t2) #['(1', '2', "['itheima'", " 'itcast'])"]

在这里插入图片描述

5. 字符串的规整操作
在这里插入图片描述

if __name__ == '__main__':
    t1 = "12who are you21"
    t2 = t1.strip("12")
    print(t2)

    t3 = t1.strip("1")
    print(t3)
    
    # 由于2不是最开头和最末尾，所以不会处理
    t4 = t1.strip("2")
    print(t4)

在这里插入图片描述

6. 字符串的元素个数

if __name__ == '__main__':
    my_str = "itheima and itcast"
    count = my_str.count("it")
    print(f"字符串{my_str}中it出现的次数是: {count}")

    '''
    字符串itheima and itcast中it出现的次数是: 2)
    '''

7. 字符串的长度

if __name__ == '__main__':
    my_str = "sb"
    a  = len(my_str)
    print(a)#2

在这里插入图片描述

4.4 数据容器（序列）的切片

序列是指：内容连续、有序，可使用下标索引的一类数据容。列表、元组、字符串，均可以可以视为序列。
在这里插入图片描述

序列的切片语法：
在这里插入图片描述

切片操作不会影响序列本身。

if __name__ == '__main__':
    # 1 对list进行切片，从1开始，4结束，步长1
    my_list = [0, 1,2, 3,4, 5,6]
    result1 = my_list[1:4]
    # 步长默认是1,所以可以省略不写
    print(f"结果1: {result1}")

    # 2 对tuple进行切片，从头开始，到最后结束，步长1
    my_tuple = (0,1, 2,3, 4,5,6)
    result2 = my_tuple[:]
    # 起始和结束不写表示从头到尾，步长为1可以省略
    print(f"结果2: {result2}")

    # 3 对str进行切片，从头开始，到最后结束,步长2
    my_str = "01234567"
    result3 = my_str[::2]
    print(f"结果3: {result3}")

    # 4 对str进行切片，从头开始，到最后结束，步长-1
    my_str = "01234567"
    result4 = my_str[::-1]
    # 等同于将序列反转了
    print(f"结果4: {result4}")

    # 5 对列表进行切片，从3开始，到1结束，步长-1
    my_list = [0,1, 2, 3, 4, 5, 6]
    result5 = my_list[3:1:-1]
    print(f"结果5: {result5}")

    # 6 对元组进行切片，从头开始，到尾结束，步长-2
    my_tupLe = (0,1, 2, 3, 4,5,6)
    result6 = my_tupLe[::-2]
    print(f"结果6: {result6}")

    '''
    结果1: [1, 2, 3]
    结果2: (0, 1, 2, 3, 4, 5, 6)
    结果3: 0246
    结果4: 76543210
    结果5: [3, 2]
    结果6: (6, 4, 2, 0)
    '''

在这里插入图片描述

4.5 集合的定义和操作

集合的语法：
在这里插入图片描述

集合set的特点：

1）集合是无序的。
2）集合的元素是去重的。

集合的方法。
在这里插入图片描述

1. 添加新元素

if __name__ == '__main__':
    # 定义集合
    my_set = {"传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima"}
    print(my_set)# 注意，set是自动去重的.

    my_set.add("Python")
    print(my_set)

注意，因为set是自动去重的，所以有重复的元素只会保存一个。而且set是无序的，所以每次打印输出结果是无序的。
在这里插入图片描述

2. 移除元素

if __name__ == '__main__':
    # 定义集合
    my_set = {"1", "2", "1", "2"}
    print(my_set)

    my_set.remove("2")
    print(my_set)

在这里插入图片描述

3. 随机移除元素
在这里插入图片描述

if __name__ == '__main__':
    # 定义集合
    my_set = {"1","2", "3", "1"}
    print(my_set)

    a = my_set.pop()
    print(a)
    print(my_set)

可以看到下面，运行多次，pop是随机移除一个元素。
在这里插入图片描述

4. 清空元素

if __name__ == '__main__':
    # 定义集合
    my_set = {"1", "2", "3", "4", "5"}
    print(my_set)

    a = my_set.clear()
    print(a)
    print(my_set)

在这里插入图片描述

5. 取俩个集合的差集
在这里插入图片描述

if __name__ == '__main__':
    set1 = {1, 2, 3}
    set2 = {1, 5, 6}
    set3 = set1.difference(set2)
    print(set3)    # 结果:{2，3}    得到的新集合
    print(set1)    # 结果:{1，2，3}不变
    print(set2)    # 结果:{1, 5，6}不变

在这里插入图片描述

6. 消除2个集合的差集

在这里插入图片描述

if __name__ == '__main__':
    set1 = {1, 2, 3}
    set2 = {1, 5, 6}
    set1.difference_update(set2)
    print(set1)
    # 结果:{2，3}
    print(set2)
    # 结果:{1，5，6}

在这里插入图片描述

7. 2个集合合并
在这里插入图片描述

if __name__ == '__main__':
    set1 = {1, 2, 3}
    set2 = {1, 5, 6}
    set3 = set1.union(set2)
    print(set3)
    # 结果:{1，2，3，5，6}，新集合,1会去重
    print(set1)
    # 结果:{1，2，3}，set1不变
    print(set2)
    # 结果:{1，5，6}，set2不变

在这里插入图片描述

8. 集合长度

if __name__ == '__main__':
    set1 = {1, 2, 3}
    print(len(set1))#3

9. 集合的遍历
因为集合不能用于索引下标，所以只能用for循环进行遍历，while循环不可以使用。

if __name__ == '__main__':
    set1 = {1, 2, 13, 4, 5}
    for eLement in set1:
        print(f"集合的元素有: {eLement}")

在这里插入图片描述

4.6 字典的定义

在这里插入图片描述

if __name__ == '__main__':
    my_dict1 = { "k1":99,"k2":75 ,"k3":75}
    my_dict2 ={}
    my_dict3 = dict()
    print(f"字典1的内容是: {my_dict1},类型: {type(my_dict1)}")
    print(f"字典2的内容是: {my_dict2}，类型: {type(my_dict2)}")
    print(f"字典3的内容是: {my_dict3},类型: {type(my_dict3)}")

    '''
    字典1的内容是: {'k1': 99, 'k2': 75, 'k3': 75},类型: <class 'dict'>
    字典2的内容是: {}，类型: <class 'dict'>
    字典3的内容是: {},类型: <class 'dict'>
    '''

在这里插入图片描述

字典的注意事项需要注意一下。
在这里插入图片描述

字典可以嵌套。

if __name__ == '__main__':
    my_dict1 = { "k1": {"语文":77,"数学":66,"英语":33},
                 "k2":{"语文":88,"数学":66,"英语":33} ,
                 "k3":{"语文":99,"数学":66,"英语":33}}

    print(f"字典1的内容是: {my_dict1},类型: {type(my_dict1)}")
    score = my_dict1["k1"]["语文"]
    print(score)

在这里插入图片描述

4.6.1 字典的常用操作

1. 新增/更新元素

语法：字典[Key] = Value
当key不存在，表示新增
当key存在，表示更新，即修改Value。

if __name__ == '__main__':
    d1 = {}
    d1["k1"] = "who"
    print(d1)
    print(type(d1))

    d1["k1"] = "are"
    print(d1)
    print(type(d1))

在这里插入图片描述

2. 删除元素

语法：字典.pop(Key) 
结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除

if __name__ == '__main__':
    my_dict1 = { "k1": {"语文":77,"数学":66,"英语":33},
                 "k2":{"语文":88,"数学":66,"英语":33} ,
                 "k3":{"语文":99,"数学":66,"英语":33}}

    print(f"字典1的内容是: {my_dict1},类型: {type(my_dict1)}")
    a = my_dict1.pop("k1")
    print(f"字典1的内容是: {my_dict1},类型: {type(my_dict1)}")

在这里插入图片描述

3. 清空元素

语法：字典.clear()

if __name__ == '__main__':
    my_dict1 = { "k1": {"语文":77,"数学":66,"英语":33},
                 "k2":{"语文":88,"数学":66,"英语":33} ,
                 "k3":{"语文":99,"数学":66,"英语":33}}

    print(f"字典1的内容是: {my_dict1},类型: {type(my_dict1)}")
    my_dict1.clear()
    print(f"字典1的内容是: {my_dict1},类型: {type(my_dict1)}")

在这里插入图片描述

4. 获取全部的key

语法：字典.keys(),结果：得到自带那种的全部Key

if __name__ == '__main__':
    my_dict1 = { "k1": {"语文":77,"数学":66,"英语":33},
                 "k2":{"语文":88,"数学":66,"英语":33} ,
                 "k3":{"语文":99,"数学":66,"英语":33}}

    print(f"字典1的内容是: {my_dict1},类型: {type(my_dict1)}")
    keys = my_dict1.keys()
    print(keys)

在这里插入图片描述

5. 遍历字典

语法：只能for 不能while 因为他不支持下标索引！！！！

if __name__ == '__main__':
    my_dict = { "k1": {"语文":77,"数学":66,"英语":33},
                 "k2":{"语文":88,"数学":66,"英语":33} ,
                 "k3":{"语文":99,"数学":66,"英语":33}}
    keys = my_dict.keys()
    # 方式1:通过获取到全部的key来完成遍历
    for key in keys:
        print(f"字典的key是: {key}")
        print(f"字典的value是: {my_dict[key]}")
    # 方式2:直接对字典进行for循环，每一次循环都是直接得到key
    for key in my_dict:
        print(f"2字典的key是: {key}")
        print(f"2字典的value是: {my_dict[key]}")

在这里插入图片描述

6. 统计字典内的元素数量

语法：len(字典)

if __name__ == '__main__':
    my_dict = { "k1": {"语文":77,"数学":66,"英语":33},
                 "k2":{"语文":88,"数学":66,"英语":33} ,
                 "k3":{"语文":99,"数学":66,"英语":33}}
    print(len(my_dict))#3

在这里插入图片描述

五五类数据容器的总结对比

在这里插入图片描述

六数据容器的通用操作

这里主要讲述不同容器之间的转换。

if __name__ == '__main__':
    my_list = [1, 2, 3, 4, 5]
    my_tuple = (1, 2, 3, 4, 5)
    my_str = "abcdefg"
    my_set = {1, 2, 3, 4, 5}
    my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

    # 1 类型转换:容器转列表
    print(f"列表转列表的结果是: {list(my_list)}")
    print(f"元组转列表的结果是: {list(my_tuple)}")
    print(f"字串转列表结果是:   {list(my_str)}")
    print(f"集合转列表的结果是: {list(my_set)}")
    print(f"字典转列表的结果是: {list(my_dict)}")# 字典的value没了

    print("======================")

    # 2 类型转换:容器转元组
    print(f"列表转元组的结果是: {tuple(my_list)}")
    print(f"元组转元组的结果是: {tuple(my_tuple)}")
    print(f"字串转元组结果是:  {tuple(my_str)}")
    print(f"集合转元组的结果是: {tuple(my_set)}")
    print(f"字典转元组的结果是: {tuple(my_dict)}")# 字典的value没了

    print("======================")

    # 3 类型转换:容器转字符串
    print(f"列表转字符串的结果是: {str(my_list)}")
    print(f"元组转字符串的结果是: {str(my_tuple)}")
    print(f"字串转字符串结果是:  {str(my_str)}")
    print(f"集合转字符串的结果是: {str(my_set)}")
    print(f"字典转字符串的结果是: {str(my_dict)}")

    print("======================")

    # 4 类型转换:容器转集合
    print(f"列表转集合的结果是: {set(my_list)}")
    print(f"元组转集合的结果是: {set(my_tuple)}")
    print(f"字串转集合结果是:  {set(my_str)}")
    print(f"集合转集合的结果是: {set(my_set)}")
    print(f"字典转集合的结果是: {set(my_dict)}")# 字典的value没了，且无序

    # 5 类型转换:容器转字典(会报错)
    # print(f"列表转字典的结果是: {dict(my_list)}")
    # print(f"元组转字典的结果是: {dict(my_tuple)}")
    # print(f"字串转字典结果是:  {dict(my_str)}")
    # print(f"集合转字典的结果是: {dict(my_set)}")
    # print(f"字典转字典的结果是: {dict(my_dict)}")

在这里插入图片描述

七容器通用排序和功能

容器通用排序和功能。
sorted（容器，[reverse = True]）
其中，最重要的是，排序结果变成了列表！！！！字典value丢失。

if __name__ == '__main__':
    my_list = [3, 1, 2, 5, 4]
    my_tuple = (3, 1, 2, 5, 4)
    my_str = "bdcefga"
    my_set = {3, 1, 2, 5, 4}
    my_dict = {"key3": 1,"key1": 2,"key2": 3,"key5": 4,"key4": 5}
    print(f"列表对象的排序结果: {sorted(my_list)}" )
    print(f"元组对象的排序结果: {sorted(my_tuple)}")
    print(f"字符串对象的排序结果: {sorted(my_str)}")
    print(f"集合对象的排序结果: {sorted(my_set)}" )
    print(f"字典对象的排序结果: {sorted(my_dict)}")
    print("======================")
    print(f"列表type: {type(sorted(my_list))}" )
    print(f"元组type: {type(sorted(my_tuple))}")
    print(f"字符串type: {type(sorted(my_str))}")
    print(f"集合type: {type(sorted(my_set))}" )
    print(f"字典type: {type(sorted(my_dict))}")

    print("======================")
    print(f"列表对象的排序结果: {sorted(my_list,reverse=True)}" )
    print(f"元组对象的排序结果: {sorted(my_tuple,reverse=True)}")
    print(f"字符串对象的排序结果: {sorted(my_str,reverse=True)}")
    print(f"集合对象的排序结果: {sorted(my_set,reverse=True)}" )
    print(f"字典对象的排序结果: {sorted(my_dict,reverse=True)}")

在这里插入图片描述

八拓展字符串大小比较方式

python的字符串比较和C/C++是一样的，都是通过ascii码进行比较。
在这里插入图片描述

if __name__ == '__main__':
    # abc比较abd
    print(f"abd大于abc，结果: {'abd' > 'abc'}")
    # a比较ab
    print(f"ab大于a，结果: {'ab' > 'a'}")
    # a比较A
    print(f"a大于A，结果: {'a' > 'A'}")
    # key1比较key2
    print(f"key2 > key1， 结果: {'key2' > 'key1'}")

在这里插入图片描述

Mango酱

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python基础----04-----函数、数据容器(列表list、元祖tuple、字符串str、集合set、字典dict，包括容器序列的切片操作)、容器之间的转换、容器sorted排序、字符串大小比

3"""如果函数没有使用return语句返回数据，那么函数有返回值吗?实际上是：有的。Python中有一个特殊的字面量: None, 其类型是: <class ‘NoneType’>无返回值的函数，实际上就是返回了： None这个字面量。None作为一个特殊的字面量，用于表示:空、无意义，其有非常多的应用场景。用在函数无返回值上。用在if判断上。在if判断中，None等同于False，一般用于在函数中主动返回None，配合if判断做相关处理。用于声明无内容的变量上。
复制链接

扫一扫