• Python编程从入门到实践(第2版)个人学习笔记

    这是本人学习Python编程从入门到实践(第2版)个人学习笔记，书本如下

    目录

    一、变量和简单数据类型

    1.1字符串和数

    1.1.1字符串部分方法的使用

    1.1.2 f 字符串的用法

    1.1.3删除空白

    1.1.4数中的下划线

    1.1.5同时给多个变量赋值

    二、列表简介

    2.1列表(list)

    2.1.1概念引入

    2.1.2访问列表元素

    2.1.3查找某元素的下标（index方法）

    2.2修改、添加和删除元素

    2.2.1修改列表元素

    2.2.2在列表中添加元素

    2.2.3在列表中删除元素

    2.3组织列表

    2.3.1使用sort()方法对列表永久排序

    2.3.2使用函数sorted() 对列表临时排序

    2.3.3倒着打印列表

    2.4操作列表

    2.4.1遍历列表

    2.4.2创建数值列表

    2.4.4切片

    2.4.5复制列表

    2.5元组（tuple）

    2.6集合 （set）

    三、字典

    3.1使用字典

    3.1.1访问字典

    3.1.2添加键值对

    3.1.3修改字典的值

    3.1.4删除键值对

    3.1.5使用 get() 来访问值

    3.1.6获取全部的key

    3.2遍历字典

    3.2.1遍历所有键值对

    3.2.2遍历字典中的所有键

    3.2.3遍历字典中的值

    3.3嵌套

    3.3.1字典列表

    3.3.2在字典中存储列表

    四、用户输入和while循环

    4.1函数input

    4.2while循环

    4.2.1while简介

    4.2.2使用while循环处理列表和字典

    五、函数

    5.1函数定义与调用

    5.2函数返回值

    5.2.1返回简单值

    5.2.2返回字典

    5.2.3传递列表

    5.2.4在函数中修改列表

    5.3传递任意数量的实参

    5.3.1结合使用位置实参和任意数量实参

    5.3.2使用任意数量的关键字实参

    5.3函数作为参数传递和lambda 匿名函数

    5.3.1函数作为参数

     5.3.2 lambda匿名函数

    5.4将函数存储在模块中

    5.4.1导入整个模块：

    5.4.2导入特定的函数

    5.4.3使用as给函数指定别名

    5.4.4使用as给模块指定别名

    六、类

    6.1创建和使用类

    6.1.1魔术方法__str__

    6.1.2__lt__小于符号比较方法

     6.1.3__le__小于等于符号比较方法

     6.1.4__eq__等于符号比较方法 

    6.2使用类和实例

    6.2.1Car类

    6.2.2给属性指定默认值

    6.2.3修改属性的值

    6.3继承

    6.3.1子类的方法__init__()

    6.3.2给子类定义属性和方法

    6.3.3将实例用作属性

    6.4导入类

    6.4.1导入单个类

    6.4.2在一个模块中存储多个类

    6.4.3从一个模块中导入多个类

    6.4.4导入整个模块

    6.4.5导入模块的所有类

    6.5类型注解

    6.5.1变量的类型注释

    6.5.2函数和方法类型注解

    6.5.3Union联合类型注解

    一、变量和简单数据类型

    1.1字符串和数

    1.1.1字符串部分方法的使用

    注意：同元组一样，字符串是一个：无法修改的数据容器。

    ①方法title()以首字母大写的方式显示每个单词；方法upper()和方法lower()将字符改为全部大写或全部小写。

    1. name = "ada loveace"
    2. print(name.title())
    3. print(name.upper())
    4. print(name.lower())

    运行结果为

    1. Ada Loveace
    2. ADA LOVEACE
    3. ada loveace

     ②取特定字符的索引

    1. name = "ada loveace"
    2. print(name.index("l"))

    运行结果：

    4

     ③通过下标索引取值

    1. name = "ada loveace"
    2. print(name[2])

    运行结果：

    a

     ④字符串的分割

    1. name = "ada loveace hello world"
    2. temp = name.split(" ")
    3. print(temp)

    运行结果：

    ['ada', 'loveace', 'hello', 'world']

    1.1.2 f 字符串的用法

    在字符串中使用变量

    1. first_name = "ada"
    2. last_name = "lovelace"
    3. fullname = f"{first_name} {last_name}"
    4. print(fullname)

    运行结果为

    ada lovelace

    f字符串的其他用法

    1. first_name = "ada"
    2. last_name = "lovelace"
    3. fullname = f"{first_name} {last_name}"
    4. print(f"Hello,{fullname.title()}!")

    运行结果

    Hello,Ada Lovelace!

    1.1.3删除空白

    rstrip()方法删除字符串末尾多余的空白；lstrip()方法删除字符串开头多余的空白；strip()方法删除字符串开头和末尾多余的空白（或指定值 ）；

    1. favorite_language = '    Python '
    2. print(favorite_language.strip())

    运行结果

    Python

    1.1.4数中的下划线

    1. favorite_num = 100_450_100
    2. print(favorite_num)

    运行结果

    100450100

    1.1.5同时给多个变量赋值

    1. x, y, z = 1, 2, 0
    2. print(f"{x} + {y}")

    运行结果

    1 + 2

    二、列表简介

    2.1列表(list)

    2.1.1概念引入

    在Python中，用方括号[]表示为列表，并用逗号分隔其中的元素。

    1. bicycles = ['trek', 'cannondable', 'redline', 'specialized']
    2. print(bicycles)

    运行结果

    ['trek', 'cannondable', 'redline', 'specialized']

    2.1.2访问列表元素

    可采用索引的方式进行访问，索引是从0开始的，返回元素不包含方括号

    1. bicycles = ['trek', 'cannondable', 'redline', 'specialized']
    2. print(bicycles[1])
    3. print(bicycles[-1])
    4. print(bicycles[-2])
    5. print(bicycles[1].title())

    运行结果

    1. cannondable
    2. specialized
    3. redline
    4. Cannondable

    2.1.3查找某元素的下标（index方法）

    功能：查找指定元素在列表中的下标，如果找不到，报错ValueError

    1. bicycles = ['trek', 'cannondable', 'redline', 'specialized']
    2. index = bicycles.index('redline')
    3. print(index)

    运行结果

    2

    2.2修改、添加和删除元素

    2.2.1修改列表元素

    1. bicycles = ['trek', 'cannondable', 'redline', 'specialized']
    2. bicycles[1] = 'hello'
    3. print(bicycles)

    运行结果

    ['trek', 'hello', 'redline', 'specialized']

    2.2.2在列表中添加元素

    在列表末尾添加单个元素

    1. bicycles = ['trek', 'cannondable', 'redline', 'specialized']
    2. bicycles.append('hello world')
    3. print(bicycles)

    运行结果

    ['trek', 'cannondable', 'redline', 'specialized', 'hello world']

    在列表末尾添加多项元素

    1. bicycles = ['trek', 'cannondable', 'redline', 'specialized']
    2. car = ["audi", "BYD"]
    3. bicycles.extend(car)
    4. print(bicycles)

    运行结果

    ['trek', 'cannondable', 'redline', 'specialized', 'audi', 'BYD']

    在列表中插入元素

    1. bicycles = ['trek', 'cannondable', 'redline', 'specialized']
    2. bicycles.insert(1, 'hello')
    3. print(bicycles)

    运行结果

    ['trek', 'hello', 'cannondable', 'redline', 'specialized']

    2.2.3在列表中删除元素

    使用 del 语句删除元素

    1. bicycles = ['trek', 'cannondable', 'redline', 'specialized']
    2. del bicycles[0]
    3. print(bicycles)

    运行结果如下

    ['cannondable', 'redline', 'specialized']

    使用 pop() 方法删除元素

    方法pop() 删除列表末尾的元素，并让你能够接着使用它。

    1. bicycles = ['trek', 'cannondable', 'redline', 'specialized']
    2. pop_bicycles = bicycles.pop()
    3. print(bicycles)
    4. print(pop_bicycles)

    运行结果

    1. ['trek', 'cannondable', 'redline']
    2. specialized

    使用pop()方法弹出列表中任何位置的元素

    1. bicycles = ['trek', 'cannondable', 'redline', 'specialized']
    2. pop_bicycles = bicycles.pop(2)
    3. print(bicycles)
    4. print(pop_bicycles)

    运行结果

    1. ['trek', 'cannondable', 'specialized']
    2. redline

    当然，别忘了，当使用pop()时，被弹出的元素就不在列表中了。

    根据值删除列表元素

    如果只知道眼删除列表元素的值，可以用方法remove()

    1. bicycles = ['trek', 'cannondable', 'redline', 'specialized']
    2. bicycles.remove('redline')
    3. print(bicycles)

    运行结果

    ['trek', 'cannondable', 'specialized']

    注意：方法 remove() 只删除第一个指定的值。

    2.3组织列表

    2.3.1使用sort()方法对列表永久排序

    按字母顺序排列

    1. cars = ['bwm', 'audi', 'toyota', 'subaru']
    2. cars.sort()
    3. print(cars)
    4. cars.sort(reverse=True) # 字母反序
    5. print(cars)

    运行结果

    1. ['audi', 'bwm', 'subaru', 'toyota']
    2. ['toyota', 'subaru', 'bwm', 'audi']

    2.3.2使用函数sorted() 对列表临时排序

    1. cars = ['bwm', 'audi', 'toyota', 'subaru']
    2. print('Here is the original list: ')
    3. print(cars)
    4. print('Here is the sorted list: ')
    5. print(sorted(cars))
    6. print('Here is the original list: ')
    7. print(cars)

    运行结果

    1. Here is the original list: 
    2. ['bwm', 'audi', 'toyota', 'subaru']
    3. Here is the sorted list: 
    4. ['audi', 'bwm', 'subaru', 'toyota']
    5. Here is the original list: 
    6. ['bwm', 'audi', 'toyota', 'subaru']

    2.3.3倒着打印列表

    可使用方法 reverse() 反转列表元素的排列顺序

    1. cars = ['bwm', 'audi', 'toyota', 'subaru']
    2. print('Here is the original list: ')
    3. print(cars)
    4. print('Here is the reverse list: ')
    5. cars.reverse()
    6. print(cars)

    运行结果

    1. Here is the original list: 
    2. ['bwm', 'audi', 'toyota', 'subaru']
    3. Here is the reverse list: 
    4. ['subaru', 'toyota', 'audi', 'bwm']

    2.4操作列表

    2.4.1遍历列表

    采用for 循环遍历列表

    1. cars = ['bwm', 'audi', 'toyota', 'subaru']
    2. for car in cars:
    3.     print(f'My favorite car is {car}')
    4. print('END!')

    运行结果

    1. My favorite car is bwm
    2. My favorite car is audi
    3. My favorite car is toyota
    4. My favorite car is subaru
    5. END!

    采用while循环遍历列表

    1. bicycles = ['trek', 'cannondable', 'redline', 'specialized']
    2. index = 0
    3. while index < len(bicycles):
    4.     print(bicycles[index])
    5.     index += 1

    运行结果：

    1. trek
    2. cannondable
    3. redline
    4. specialized

    2.4.2创建数值列表

    使用range() 函数

    1. for value in range(1, 5):
    2.     print(value)

    运行结果：

    1. 1
    2. 2
    3. 3
    4. 4

    可见，并没有输出5。故 range(a, b) 函数中只会取值 [a, b)

    使用range() 函数创建数字列表，并进行简单统计

    1. # 默认步长为1
    2. numbers1 = list(range(1, 5))
    3. print(numbers1)
    4. # 步长自定义
    5. numbers2 = list(range(1, 10, 2))
    6. print(numbers2)
    7. print(min(numbers2))
    8. print(max(numbers2))
    9. print(sum(numbers2))

    运行结果

    1. [1, 2, 3, 4]
    2. [1, 3, 5, 7, 9]
    3. 1
    4. 9
    5. 25

    2.4.3列表解析

    方括号中首先定义一个表达式，然后编写一个for 循环给表达式赋值

    1. squares = [value**2 for value in range(1, 10)]
    2. print(squares)

    运行结果

    [1, 4, 9, 16, 25, 36, 49, 64, 81]

    2.4.4切片

    切片示意

    1. player = ['AAA', 'BBB', 'CCC', 'DDD', 'EEE']
    2. print(player[1:4])
    3. print(player[:4])
    4. print(player[1:])
    5. print(player[-2:])

    运行结果

    1. ['BBB', 'CCC', 'DDD']
    2. ['AAA', 'BBB', 'CCC', 'DDD']
    3. ['BBB', 'CCC', 'DDD', 'EEE']
    4. ['DDD', 'EEE']

    遍历切片

    1. players = ['AAA', 'BBB', 'CCC', 'DDD', 'EEE']
    2. for player in players[1:]:
    3.     print(player)

    运行结果

    1. BBB
    2. CCC
    3. DDD
    4. EEE

    2.4.5复制列表

    首先，让我们来看一下错误做法

    1. # 将my_color列表复制给your_color列表的错误做法
    2. my_color = ['red', 'yellow', 'blue']
    3. your_color = my_color
    4. print(your_color)

    运行结果

    ['red', 'yellow', 'blue']

    看起来好像没什么问题，我们对上述程序进行简单测试：

    1. # 将my_color列表复制给your_color列表的错误做法
    2. my_color = ['red', 'yellow', 'blue']
    3. your_color = my_color
    4. print(your_color)
    5. # 对my_color列表进行简单修改,弹出列表最后一个元素
    6. my_color.pop()
    7. # 分别打印出my_color和your_color列表
    8. print(my_color)
    9. print(your_color)

    运行结果如下，我们发现，对my_color列表进行修改，your_color列表也随之改变

    1. ['red', 'yellow', 'blue']
    2. ['red', 'yellow']
    3. ['red', 'yellow']

    显然，对于your_color = my_color,是将my_color赋给your_color，而不是将my_color的副本赋给your_color。即原理如下所示，这两个变量指向同一个列表：

    那如何正确进行列表的复制呢？可采用切片表示法[ : ]创建列表的副本

    1. # 将my_color列表复制给your_color列表的正确做法
    2. my_color = ['red', 'yellow', 'blue']
    3. your_color = my_color[:]
    4. print(your_color)
    5. # 对my_color列表进行简单修改,弹出列表最后一个元素
    6. my_color.pop()
    7. # 分别打印出my_color和your_color列表
    8. print(my_color)
    9. print(your_color)

     打印输出结果如下

    1. ['red', 'yellow', 'blue']
    2. ['red', 'yellow']
    3. ['red', 'yellow', 'blue']

    结果表明，对my_color列表进行修改，不影响your_color列表，这里是将my_color的副本赋给your_color。即原理如下所示，这两个变量分别指向两个列表：

    2.5元组（tuple）

     Python将不能修改的值称为不可变的，而不可变的列表被称为元组。

    定义元组，元组看起来很像列表，但使用圆括号而非中括号来标识。可以使用索引访问元组元素。

    1. dimensions = (200, 50)
    2. print(dimensions[1])
    3. # 对元组重新赋值
    4. dimensions = (300, 100)
    5. print(dimensions[1])

    运行结果

    1. 50
    2. 100

    2.6集合 （set）

    为什么需要学习集合这一类型，因为，列表可修改、支持重复元素有序；元组、字符串不可修改支持重复元素有序。如果场景需要对内容做去重处理，列表、元组、字符串就不方便了。而集合，最主要的特点就是不支持元素的重复，并且内容无序（顺序无法保证，不支持下标索引访问）。定义空集合只能用set()，不可以用{}，{}是定义空字典的。

    1. # 定义集合
    2. my_set = {"hello", "world", "audi", "BYD","hello", "world", "audi", "BYD"}
    3. my_empty_set = set()        # 定义空集合
    4. print(f"my_set的内容是：{my_set},类型是：{type(my_set)}")
    5. print(f"my_set的内容是：{my_empty_set},类型是：{type(my_empty_set)}")

    运行结果：

    1. my_set的内容是：{'hello', 'BYD', 'world', 'audi'},类型是：<class 'set'>
    2. my_set的内容是：set(),类型是：<class 'set'>

     ①集合的修改，添加新元素

    1. my_set = {"hello", "world", "audi", "BYD","hello", "world", "audi", "BYD"}
    2. my_set.add("xuan")
    3. print(f"my_set添加元素后，结果为：{my_set}")

     运行结果：

    my_set添加元素后，结果为：{'hello', 'BYD', 'xuan', 'audi', 'world'}

     ②集合的修改，移除元素 

    1. # 定义集合
    2. my_set = {"hello", "world", "audi", "BYD","hello", "world", "audi", "BYD"}
    3. my_set.remove("BYD")
    4. print(f"my_set移除元素后，结果为：{my_set}")

     运行结果

    my_set移除元素后，结果为：{'audi', 'hello', 'world'}

     ③集合中随机取出元素  

    1. my_set = {"hello", "world", "audi", "BYD","hello", "world", "audi", "BYD"}
    2. temp = my_set.pop()
    3. print(f"my_set移除元素为：{temp}")

    运行结果：

    my_set移除元素为：hello

     ④取两个集合的差集

    1. my_set1 = {1, 2, 3}
    2. my_set2 = {1, 5, 6}
    3. temp = my_set1.difference(my_set2)
    4. print(my_set1)
    5. print(my_set2)
    6. print(temp)

    运行结果（集合1有集合2没有的）

    1. {1, 2, 3}
    2. {1, 5, 6}
    3. {2, 3}

     ⑤消除两个集合的差集

    1. my_set1 = {1, 2, 3}
    2. my_set2 = {1, 5, 6}
    3. my_set1.difference_update(my_set2)
    4. print(my_set1)
    5. print(my_set2)

    运行结果：（在集合1的内部删除和集合2相同的元素）

    1. {2, 3}
    2. {1, 5, 6}

     ⑥两个集合合并

    1. my_set1 = {1, 2, 3}
    2. my_set2 = {1, 5, 6}
    3. temp = my_set1.union(my_set2)
    4. print(my_set1)
    5. print(my_set2)
    6. print(temp)

    运行结果：

    1. {1, 2, 3}
    2. {1, 5, 6}
    3. {1, 2, 3, 5, 6}

     ⑦统计集合元素数量len()

    1. my_set1 = {1, 2, 3}
    2. print(len(my_set1))

    运行结果：

    3

     ⑧集合的遍历

    集合不支持下标索引，不能用while循环，可以用for循环

    1. my_set1 = {1, 2, 3, 5, 6}
    2. for element in my_set1:
    3.     print(f"集合的元素有：{element}")

    运行结果：

    1. 集合的元素有：1
    2. 集合的元素有：2
    3. 集合的元素有：3
    4. 集合的元素有：5
    5. 集合的元素有：6

    三、字典

    定义空字典可以用{}或dict()

    3.1使用字典

    3.1.1访问字典

    在Python中，字典是一系列键值对，首先创建一个字典。

    1. alien_0 = {'color': 'green', 'points': 5}
    2. print(alien_0['points'])

    运行结果

    5

    3.1.2添加键值对

    1. alien_0 = {'color': 'green', 'points': 5}
    2. alien_0['hello'] = 'xuan'
    3. print(alien_0)
    4. print(alien_0['points'])

    运行结果

    1. {'color': 'green', 'points': 5, 'hello': 'xuan'}
    2. 5

    3.1.3修改字典的值

    1. alien_0 = {'color': 'green', 'points': 5}
    2. alien_0['points'] = 10
    3. print(alien_0)

    运行结果

    {'color': 'green', 'points': 10}

    3.1.4删除键值对

    方法一：

    1. alien_0 = {'color': 'green', 'points': 5}
    2. del alien_0['points']
    3. print(alien_0)

    运行结果

    {'color': 'green'}

     方法二：

    1. alien_0 = {'color': 'green', 'points': 5}
    2. temp = alien_0.pop('points')
    3. print(alien_0)
    4. print(temp)

    运行结果：

    1. {'color': 'green'}
    2. 5

    3.1.5使用 get() 来访问值

    如果访问字典中的键不存在，那么访问会报错，例如

    1. alien_0 = {'color': 'green', 'points': 5}
    2. print(alien_0['hello'])

    运行结果

    1. Traceback (most recent call last):
    2.   File "D:\exercise\python\pythonProject\hello.py", line 2, in 
    3.     print(alien_0['hello'])
    4. KeyError: 'hello'

    对此可使用方法get() 在指定的键不存在时返回一个默认值。

    1. alien_0 = {'color': 'green', 'points': 5}
    2. hello_err = alien_0.get('hello', 'No hello')
    3. print(hello_err)

    运行结果

    No hello

    3.1.6获取全部的key

    1. alien_0 = {'color': 'green', 'points': 5}
    2. print(alien_0.keys())

     运行结果

    dict_keys(['color', 'points'])

    3.2遍历字典

    3.2.1遍历所有键值对

    方法items() 返回一个键值对列表

    1. alien_0 = {'color': 'green', 'points': 5}
    2. for key, valur in alien_0.items():
    3.     print(f'{key} : {valur}')

    运行结果

    1. color : green
    2. points : 5

    3.2.2遍历字典中的所有键

    采用方法keys()返回一个列表，包含字典的所有的键

    1. alien_0 = {'color': 'green', 'points': 5}
    2. for key in alien_0.keys():
    3.     print(f'The key :{key} ')

    运行结果

    1. The key :color 
    2. The key :points

    3.2.3遍历字典中的值

    采用values() 方法可返回一个列表，包含字典中所有的值。为剔除重复值可用set() 函数。

    1. alien_0 = {'color': 'green', 'points': 5, 'lovecolor': 'green'}
    2. for value in alien_0.values():
    3.     print(f'The value :{value} ')
    4. # 剔除重复项
    5. print('-------------------------------------')
    6. for value in set(alien_0.values()):
    7.     print(f'The value :{value} ')

    运行结果

    1. The value :green 
    2. The value :5 
    3. The value :green 
    4. -------------------------------------
    5. The value :5 
    6. The value :green

    3.3嵌套

    3.3.1字典列表

    所谓字典列表就是在列表中存储字典

    1. alien_0 = {'color': 'green', 'point': 5}
    2. alien_1 = {'color': 'yellow', 'point': 10}
    3. alien_2 = {'color': 'red', 'point': 15}
    4. alien = [alien_0, alien_1, alien_2]
    5. print(alien)
    6.  
    7. # 循环创建
    8. print('---------------------------------------')
    9. for alien_num in range(5):
    10.     alien_num = {'color': 'green', 'point': 5}
    11.     alien.append(alien_num)
    12. for num in alien:
    13.     print(num)

    运行结果

    1. [{'color': 'green', 'point': 5}, {'color': 'yellow', 'point': 10}, {'color': 'red', 'point': 15}]
    2. ---------------------------------------
    3. {'color': 'green', 'point': 5}
    4. {'color': 'yellow', 'point': 10}
    5. {'color': 'red', 'point': 15}
    6. {'color': 'green', 'point': 5}
    7. {'color': 'green', 'point': 5}
    8. {'color': 'green', 'point': 5}
    9. {'color': 'green', 'point': 5}
    10. {'color': 'green', 'point': 5}

    3.3.2在字典中存储列表

    在程序语言设计中，更多的是将列表存储在字典中，对于新手来说，如何快速上手，下面便通过小例子进行讲解

    1. # 建立一个存储披萨信息的字典
    2. pizza = {
    3.     'crust': 'thick',
    4.     # 字典中包含两个元素的列表
    5.     'toppings': ['mushrooms', 'extra cheese']
    6. }
    7.  
    8. print(f"You ordered a {pizza['crust']}-crust pizza"
    9.       " with the following toppings:")
    10.  
    11. for topping in pizza['toppings']:
    12.     print('\t'+ topping)

    打印输出如下结果：

    1. You ordered a thick-crust pizza with the following toppings:
    2. 	mushrooms
    3. 	extra cheese

    3.3.3在字典中存储字典

    在python中，在字典中包含字典信息，并逐个遍历

    1. # 定义一个名为user的字典，该字典中包含两个字典
    2. user = {
    3.     'aeinstein': {
    4.         'first': 'albert',
    5.         'last': 'einstein',
    6.         'location': 'princeton',
    7.     },
    8.     # 上一行末尾的逗号不要忘了
    9.     'mcurie': {
    10.         'first': 'marie',
    11.         'last': 'curie',
    12.         'location': 'paris',
    13.     },
    14.     # 同样的，上一行末尾的逗号不要忘了
    15. }
    16.  
    17. # 遍历字典user，依次将两个健赋给变量username，将当前健所对应的信息赋给变量user_info
    18. for username, user_info in user.items():
    19.     print(f"Username: {username}")
    20.     print(f"Fullname: {user_info['first'] }{user_info['last']}")
    21.     print(f"Location: {user_info['location']}\n")

    遍历该字典，输出以下结果

    1. Username: aeinstein
    2. Fullname: alberteinstein
    3. Location: princeton
    4.  
    5. Username: mcurie
    6. Fullname: mariecurie
    7. Location: paris

    四、用户输入和while循环

    4.1函数input

    函数input(） 让程序暂停运行，等待用户输入一些文本，获取输入后，Python将其赋值给一个变量。

    1. name = input('Please enter your name: ')
    2. print(f'your name is {name}')

    输出结果

    1. Please enter your name: Erick
    2. your name is Erick

    input读取作为一个字符串，那么如何读取数值呢，需要强制类型转换

    1. age = int(input('Please enter your age: '))
    2. print(f'your name is {age}')

    输出结果

    1. Please enter your age: 18
    2. your name is 18

    4.2while循环

    4.2.1while简介

    while循环示例，包括break用法：

    1. prompt = "\nTell me something, and I will repeat it back to you."
    2. prompt += "\nEnter 'quit' to end the program."
    3. active = True
    4. while active:
    5.     message = input(prompt)
    6.     if message == 'quit':
    7.         break
    8.     else:
    9.         print(message)

    运行结果

    1. Tell me something, and I will repeat it back to you.
    2. Enter 'quit' to end the program.hello everyone
    3. hello everyone
    4.  
    5. Tell me something, and I will repeat it back to you.
    6. Enter 'quit' to end the program.jim bob
    7. jim bob
    8.  
    9. Tell me something, and I will repeat it back to you.
    10. Enter 'quit' to end the program.quit

    在循环中使用continue

    1. current_num = 0
    2. while current_num < 10:
    3.     current_num += 1
    4.     if current_num % 2 == 0:
    5.         continue
    6.     print(current_num)

    运行结果：

    1. 1
    2. 3
    3. 5
    4. 7
    5. 9

    4.2.2使用while循环处理列表和字典

    示例：

    1. # 首先，创建一个待验证的用户列表
    2. # 和一个用于存储已验证用户的空列表
    3. unconfirmed_users = ['alice', 'brian', 'candace']
    4. confirmed_users = []
    5.  
    6. # 验证每个用户，直到没有未验证用户为止
    7. # 将每个经过验证的用户都移动到已验证用户列表中
    8. while unconfirmed_users:
    9.     current_user = unconfirmed_users.pop()
    10.  
    11.     print(f'Verifying user: {current_user.title()}')
    12.     confirmed_users.append(current_user)
    13.  
    14. # 显示所有已验证的用户
    15. print("\nThe follwing users have been confirmed: ")
    16. for confirmed_user in confirmed_users:
    17.     print(confirmed_user.title())

    输出：

    1. Verifying user: Candace
    2. Verifying user: Brian
    3. Verifying user: Alice
    4.  
    5. The follwing users have been confirmed: 
    6. Candace
    7. Brian
    8. Alice

    4.2.3删除特定值的所有列表元素

    1. pets = ['dog', 'cat', 'dag', 'goldfish', 'cat', 'rabbit', 'cat']
    2. print(pets)
    3.  
    4. while 'cat' in pets:
    5.     pets.remove('cat')
    6.  
    7. print(pets)

    运行结果

    1. ['dog', 'cat', 'dag', 'goldfish', 'cat', 'rabbit', 'cat']
    2. ['dog', 'dag', 'goldfish', 'rabbit']

    五、函数

    5.1函数定义与调用

    该例子中包含函数定义，默认参数，关键字实参等知识

    例子：

    1. def describe_pet(animal_type, pet_name='dog'):
    2.     """显示宠物信息"""
    3.     print(f"\nI have a {animal_type}")
    4.     print(f"My {animal_type}'s name is {pet_name}.")
    5.  
    6.  
    7. describe_pet('harry', 'hamster')
    8. describe_pet('Willie')
    9. describe_pet(pet_name='harry', animal_type='hamster')

    运行结果

    1. I have a harry
    2. My harry's name is hamster.
    4. I have a Willie
    5. My Willie's name is dog.
    6.  
    7. I have a hamster
    8. My hamster's name is harry.

    5.2函数返回值

    5.2.1返回简单值

    1. def get_formatted_name(first_name, last_name):
    2.     """返回完整姓名"""
    3.     full_name = f"{first_name} {last_name}"
    4.     return full_name
    5.  
    6.  
    7. musician = get_formatted_name('jimi', 'hendrix')
    8. print(musician)

    运行结果

    jimi hendrix

    5.2.2返回字典

    1. def build_name(first_name, last_name, age=None):
    2.     """返回完整姓名"""
    3.     person = {'first':first_name, 'last':last_name}
    4.     if age:
    5.         person['age'] = age
    6.     return person
    7.  
    8.  
    9. musician1 = build_name('jimi', 'hendrix')
    10. musician2 = build_name('bob', 'eric', 18)
    11. print(musician1)
    12. print(musician2)

    运行结果

    1. {'first': 'jimi', 'last': 'hendrix'}
    2. {'first': 'bob', 'last': 'eric', 'age': 18}

    5.2.3传递列表

    将列表作为参数传递给函数形参。

    1. def greet_users(names):
    2.     """向列表中的每位用户都发出简单的问候"""
    3.  
    4.     for name in names:
    5.         msg = f'Hello, {name.title()}!'
    6.         print(msg)
    7.  
    8.  
    9. usernames = ['jim', 'jack', 'bob']
    10. greet_users(usernames)

    运行结果

    1. Hello, Jim!
    2. Hello, Jack!
    3. Hello, Bob!

    5.2.4在函数中修改列表

    1. designs = ['phone case', 'robot pendant', 'dodecahedron']
    2. models = []
    3.  
    4. # 模拟打印每个设计，直到没有未打印的设计为止
    5. #  打印每个设计后，都将其移到列表completed_models中
    6. while designs:
    7.     design = designs.pop()
    8.  
    9.     # 模拟根据设计制作3D打印模型的过程
    10.     print(f"Printing model: {design}")
    11.     models.append(design)
    12.  
    13. # 显示打印好的所有模型
    14. print("\nThe following models have been printed:")
    15. for model in models:
    16.     print(model)

    运行结果

    1. The following models have been printed:
    2. dodecahedron
    3. robot pendant
    4. phone case

    对上述代码改进

    1. def print_models(designs, models):
    2.     """
    3.     模拟打印每个设计，直到没有未打印的设计为止
    4.     打印每个设计后，都将其移到列表models中
    5.     """
    6.     while designs:
    7.         design = designs.pop()
    8.         # 模拟根据设计制作3D打印模型的过程
    9.         print(f"Printing model: {design}")
    10.         models.append(design)
    11.  
    12.  
    13. def show_models(models):
    14.     """显示打印好的所有模型"""
    15.     print("\nThe following models have been printed:")
    16.     for model in models:
    17.         print(model)
    18.  
    19.  
    20. designs = ['iphone case', 'robot pendant', 'dodecahedron']
    21. models = []
    22. print_models(designs, models)
    23. show_models(models)

    运行结果

    1. The following models have been printed:
    2. dodecahedron
    3. robot pendant
    4. iphone case

    5.3传递任意数量的实参

    有时候,你预先不知道函数需要接受几个实参 , 好在python 允许从调用语句中收集任意数量的实参

    1. # 传递任意数量的实参 python
    2. def make_pizza(*toppings):
    3.     """   打印顾客点的所有配料"""
    4.     print(toppings)
    5.     
    6.     
    7. make_pizza('Pepperoni')
    8. make_pizza('mushrooms', 'green peppers', 'extra cheese')

    运行结果

    1. ('Pepperoni',)
    2. ('mushrooms', 'green peppers', 'extra cheese')

    形参名 *toppings 中的星号让python 创建一个名为toppings的空元祖 , 并将收到的所有值都封装在这的元组里 .ps(python将实参封装到一个元组中,即便函数值只收到了一个值) . 

    5.3.1结合使用位置实参和任意数量实参

    如果要让函数接受不同类型的实参 , 必须在函数定义中将接纳任意数量的实参的形参放在最后,python先匹配位置实参和关键字实参,再将余下的实参收集到最后一个形参中. 

    例如 ,如果上面的函数还需要一个表示披萨尺寸的实参, 必须将形参放在形参 *toppings的前面'

    1. def make_pizza(size, *toppings):
    2.     print("\nMaking a  " + str(size) +
    3.           "-inch pizza with the following toppings")
    4.     for topping in toppings:
    5.         print("- " + topping)
    6.  
    7.  
    8. make_pizza(16, 'pepperoni')
    9. make_pizza(12, 'mushrooms', 'green peppers ', 'extra cheese')

    运行结果

    1. Making a  16-inch pizza with the following toppings
    2. - pepperoni
    3.  
    4. Making a  12-inch pizza with the following toppings
    5. - mushrooms
    6. - green peppers 
    7. - extra cheese

    5.3.2使用任意数量的关键字实参

    有时候 ,需要接受任意数量的实参, 但预先不知道传递的函数会是什么样的信息 .在这种情况下,可以将函数编写成能够接受任意数量的键值对 ---调用语句提供了多少就接受多少 . 一个这样的实例是创建用户简介 :

    1. def build_profile(first, last, **user_info):
    2.     profile ={}
    3.     profile['first_name'] = first
    4.     profile['last_name'] = last
    5.     for key, value in user_info.items():
    6.         profile[key] = value
    7.     return profile
    8.  
    9.  
    10. user_profile = build_profile('albert', 'einstein', location='princeton', filed='physics')
    11. print(user_profile)

    运行结果

    {'first_name': 'albert', 'last_name': 'einstein', 'location': 'princeton', 'filed': 'physics'}

    5.3函数作为参数传递和lambda 匿名函数

    5.3.1函数作为参数

    1. def test_func(computer):
    2.     result = computer(1, 2)
    3.     print(f"computer的类型是：{type(computer)}")
    4.     print(f"计算结果：{result}")
    5.  
    6.  
    7. def computer(x, y):
    8.     return x+y
    9.  
    10.  
    11. test_func(computer)

    运行结果：

    1. computer的类型是：<class 'function'>
    2. 计算结果：3

     5.3.2 lambda匿名函数

    1. def test_func(computer):
    2.     result = computer(1, 2)
    3.     print(f"computer的类型是：{type(computer)}")
    4.     print(f"计算结果：{result}")
    5.  
    6.  
    7. test_func(lambda x, y:x + y)

    运行结果：

    1. computer的类型是：<class 'function'>
    2. 计算结果：3

    5.4将函数存储在模块中

    函数的优点之一是，使用它们可将代码块与主程序分离。通过给函数指定描述性名称，可让主程序容易理解得多。你还可以更进一步，将函数存储在被称为模块的独立文件中，再将模块导入到主程序中。imprt语句允许在当前运行的程序文件中使用模块中的代码。

    通过将函数存储在独立的文件中，可隐藏程序代码的细节，将重点放在程序的高级逻辑上。将函数存储在独立文件中后，可与其他程序员共享这些文件而不是整个程序。

    5.4.1导入整个模块：

    只需编写一条import语句并在其中指定模块名，就可以在程序中使用该模块的所有函数。
    pizza.py

    1. def make_pizza(size, *toppings):
    2.     print(f"\nMaking a {str(size)} -inch pizza with the following toppings:")
    3.     for topping in toppings:
    4.         print(f"- {topping}")

    making_pizzas.py

    1. import pizza
    2.  
    3. # python读取这个文件时，代码行import pizza让Python打开文件pizza.py，并将其中的
    4. # 所有函数都复制到这个程序中
    5.  
    6. pizza.make_pizza(16, 'pepperoni')
    7. pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

    上述两个 .py 文件放在一个工程目录下，运行结果

    1. Making a 16 -inch pizza with the following toppings:
    2. - pepperoni
    3.  
    4. Making a 12 -inch pizza with the following toppings:
    5. - mushrooms
    6. - green peppers
    7. - extra cheese

    5.4.2导入特定的函数

    你可以导入模块中的特定函数，这种导入方法的语法如下：

    from module_name import function_name   通过用逗号分隔函数名，可根据需要从模块中导入任意数量的函数。若使用这种语法，调用函数时就无需使用句点。

    对上述pizza.pymaking_pizzas.py进行修改

    1. from pizza import make_pizza
    2.  
    3.  
    4. make_pizza(16, 'pepperoni')
    5. make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

    运行结果和上述一致。

    5.4.3使用as给函数指定别名

    如果要导入的函数名称可能与程序中现有的名称冲突，或者函数的名称太长，可指定简短而独一无二的别名——函数的；另一个名称，类似于外号。通过关键字as将函数重命名

    对上述pizza.pymaking_pizzas.py进行修改

    1. from pizza import make_pizza as mp
    2. mp(16, 'pepperoni')
    3. mp(12, 'mushrooms', 'green peppers', 'extra cheese')

    运行结果与上述一致

    5.4.4使用as给模块指定别名

    可以给模块指定别名。通过给模块指定简短的别名，能够轻松地调用模块中的函数。

    对上述pizza.pymaking_pizzas.py进行修改

    1. import pizza as p
    2. p.make_pizza(16, 'pepperoni')
    3. p.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

    运行结果与上述一致

    5.4.5导入模块中的所有函数

    使用星号（*）运算符可以让Python导入模块中的所有函数：由于导入了每个函数，可通过名称来调用每一个函数，而无需使用句点表示法。然而并非自己编写的大型模块时，最好不要采用这种导入方法。防止名称相同。

    1. from pizza import *
    2.  
    3. make_pizza(16, 'pepperoni')
    4. make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

    运行结果与上述一致

    六、类

    6.1创建和使用类

    1. class Dog():  # 在Python中，首字母大写的名称指的是类。
    2.     """一次模拟小狗的简单尝试"""
    3.  
    4.     """__init__()是一个特殊的方法，每当根据Dog类创建新实例时，Python都会自动运行它"""
    5.  
    6.     def __init__(self, name, age):
    7.         """在这个放大的定义中self必不可少，还必须位于其他形参的前面。
    8.         Python调用这个__init__方法来创建Dog实例时，将自动传入实参self。与每个类相关联的的方法
    9.         调用都自动传递实参self它是一个指向实例本身的引用，让实例能够访问类中的属性和方法"""
    10.  
    11.         """初始化属性name和age"""
    12.  
    13.         self.name = name
    14.         """以self为前缀的变量都可供类中的所有方法使用，我们还可以通过类的任何实例来访问这些变量"""
    15.         self.age = age
    16.  
    17.     def sit(self):
    18.         """模拟小狗被命令时蹲下"""
    19.         print(self.name.title() + " is now sitting.")
    20.  
    21.     def roll_over(self):
    22.         """模拟小狗被命令时打滚"""
    23.         print(self.name.title() + "rolled over!")
    24.  
    25.  
    26. my_dog = Dog('willie', 6)
    27. """方法__init__()并未显式地包含return语句，但Python自动返回一个表示这条小狗的实例
    28. 我们将这个实例存储在  变量  my_dog中"""
    29.  
    30. print(f"My dog`s name is {my_dog.name.title()} .")
    31. print(f"My dog is {str(my_dog.age)} years old.")
    32. my_dog.sit()
    33. my_dog.roll_over()
    34. """要调用方法，可指定实例的名称和调用的方法，并用句点分隔它们。
    35. 可以按照需求根据一个类创建任意数量个实例，条件是将每个实例都存储在不同的变量中，或占用列表或字典的不同位置。"""

    运行结果

    1. My dog`s name is Willie .
    2. My dog is 6 years old.
    3. Willie is now sitting.
    4. Willierolled over!

    6.1.1魔术方法__str__

    1. class Student:
    2.     def __init__(self, name, age):
    3.         self.name = name
    4.         self.age = age
    5.  
    6.     def __str__(self):
    7.         return f"Student类对象，name:{self.name},sge:{self.age}"
    8.  
    9.  
    10. stu = Student("周树人", 30)
    11. print(stu)

     运行结果：

    Student类对象，name:周树人,sge:30

    6.1.2__lt__小于符号比较方法

    1. class Student:
    2.     def __init__(self, name, age):
    3.         self.name = name
    4.         self.age = age
    5.  
    6.     def __lt__(self, other):
    7.         return self.age < other.age
    8.  
    9.  
    10. stu1 = Student("周树人", 30)
    11. stu2 = Student("周大", 36)
    12. print(stu1 < stu2)

    运行结果：

    True

     6.1.3__le__小于等于符号比较方法

    1. class Student:
    2.     def __init__(self, name, age):
    3.         self.name = name
    4.         self.age = age
    5.  
    6.     def __le__(self, other):
    7.         return self.age <= other.age
    8.  
    9.  
    10. stu1 = Student("周树人", 30)
    11. stu2 = Student("周大", 30)
    12. print(stu1 <= stu2)

    运行结果：

    True

     6.1.4__eq__等于符号比较方法 

    1. class Student:
    2.     def __init__(self, name, age):
    3.         self.name = name
    4.         self.age = age
    5.  
    6.     def __eq__(self, other):
    7.         return self.age == other.age
    8.  
    9.  
    10. stu1 = Student("周树人", 30)
    11. stu2 = Student("周大", 31)
    12. stu3 = Student("周小", 30)
    13. print(stu1 == stu2)
    14. print(stu1 == stu3)

    运行结果

    1. False
    2. True

    6.2使用类和实例

    6.2.1Car类

    编写一个表示汽车的简单类

    1. class Car:
    2.     """一次模拟汽车的简单尝试"""
    3.     def __init__(self, make, model, year):
    4.         self.make = make
    5.         self.model = model
    6.         self.year = year
    7.  
    8.     def get_descriptive_name(self):
    9.         """返回整洁的描述性信息"""
    10.         long_name = f"{self.year} {self.make} {self.model}"
    11.         return long_name.title()
    12.  
    13.  
    14. my_car = Car('audi', 'a8', 2022)
    15. print(f"My car is  {my_car.get_descriptive_name()}")

    运行结果如下

    My car is  2022 Audi A8

    6.2.2给属性指定默认值

    创建实例时，有些属性无须通过形参来定义，可在方法__init__（）中为其指定默认值。，我们添加了一个属性名为odometer_reading，并将它的值默认为0，此外，我们还添加了一个方法read_odometer()。

    1. class Car:
    2.     """一次模拟汽车的简单尝试"""
    3.     ''''''
    4.     def __init__(self, make, model, year):
    5.         self.make = make
    6.         self.model = model
    7.         self.year = year
    8.         self.odometer_reading = 0
    9.  
    10.     def get_descriptive(self):
    11.         """返回整洁的描述性信息"""
    12.         long_name = f"{self.year} {self.make} {self.model}"
    13.         return long_name.title()
    14.  
    15.     def read_odometer(self):
    16.         """读取里程数"""
    17.         print(f"this car's meter is {self.odometer_reading} miles on it")
    18.  
    19.  
    20. my_car = Car('audi', 'a8', 2022)
    21. print(f"My car is  {my_car.get_descriptive()}")
    22. my_car.read_odometer()
    23.

    运行结果

    1. My car is  2022 Audi A8
    2. this car's meter is 0 miles on it

    6.2.3修改属性的值

    我们还可以对所添加的属性odometer_reading的值进行修改。

    ①通过实例直接修改属性值

    1. class Car:
    2.     """一次模拟汽车的简单尝试"""
    3.     def __init__(self, make, model, year):
    4.         self.make = make
    5.         self.model = model
    6.         self.year = year
    7.         self.odometer_reading = 0
    8.  
    9.     def get_descriptive(self):
    10.         """返回整洁的描述性信息"""
    11.         long_name = f"{self.year} {self.make} {self.model}"
    12.         return long_name.title()
    13.  
    14.     def read_odometer(self):
    15.         """读取里程数"""
    16.         print(f"this car's meter is {self.odometer_reading} miles on it")
    17.  
    18.  
    19. my_car=Car('audi', 'a8', 2022)
    20. print(f"my car is  {my_car.get_descriptive()}")
    21. my_car.read_odometer()
    22. my_car.odometer_reading = 23
    23. my_car.read_odometer()
    24.

    运行结果

    1. D:\APP\Anaconda\Anaconda3\python.exe D:/exercise/python/pythonProject/hello.py 
    2. my car is  2022 Audi A8
    3. this car's meter is 0 miles on it
    4. this car's meter is 23 miles on it

    ②通过方法修改属性的值

    1. class Car:
    2.     """一次模拟汽车的简单尝试"""
    3.     def __init__(self, make, model, year):
    4.         self.make = make
    5.         self.model = model
    6.         self.year = year
    7.         self.odometer_reading = 0
    8.  
    9.     def get_descriptive(self):
    10.         """返回整洁的描述性信息"""
    11.         long_name=f"{self.year} {self.make} {self.model}"
    12.         return long_name.title()
    13.  
    14.     def read_odometer(self):
    15.         """读取里程数"""
    16.         print(f"this car's meter is {self.odometer_reading} miles on it")
    17.  
    18.     def update_odometer(self,mileage):
    19.         """将里程数设置为指定的值"""
    20.         self.odometer_reading=mileage
    21.  
    22.     def increment_odometer(self, miles):
    23.         """将里程数增加指定的量"""
    24.         self.odometer_reading += miles
    25.  
    26.  
    27. my_car=Car('audi', 'a8', 2022)
    28. print(f"my car is  {my_car.get_descriptive()}")
    29. my_car.read_odometer()
    30. my_car.update_odometer(23)
    31. my_car.read_odometer()
    32. my_car.increment_odometer(10)
    33. my_car.read_odometer()

    运行结果

    1. my car is  2022 Audi A8
    2. this car's meter is 0 miles on it
    3. this car's meter is 23 miles on it
    4. this car's meter is 33 miles on it

    6.3继承

    6.3.1子类的方法__init__()

    我们创建一个新类ElectricCar（子类）让它继承父类Car的属性和方法

    代码行class ElectricCar(Car)：我们在创建新类（这里是子类）时，父类必须包含在文件中，且位于子类前面，我们定义了子类ElectricCar，并且将父类Car放在圆括号中，我们的子类要继承父类的属性和方法就必须将父类的名称指定在圆括号内。
    方法__init__()接受创建Car实例所需的信息。
    super()是一个特殊函数，让我们能够调用父类的方法。
    代码行 super().init(make,model,year)是让python调用Car类的方法__init__()，让ElectricCar中的实例包含方法__init__()中定义的所有属性。
     

    1. class Car:
    2.     """一次模拟汽车的简单尝试"""
    3.     def __init__(self, make, model, year):
    4.         self.make = make
    5.         self.model = model
    6.         self.year = year
    7.         self.odometer_reading = 0
    8.  
    9.     def get_descriptive_name(self):
    10.         """返回整洁的描述性信息"""
    11.         long_name = f"{self.year} {self.make} {self.model}"
    12.         return long_name.title()
    13.  
    14.     def read_odometer(self):
    15.         """读取里程数"""
    16.         print(f"this car's meter is {self.odometer_reading} miles on it")
    17.  
    18.     def update_odometer(self,mileage):
    19.         """将里程数设置为指定的值"""
    20.         if mileage >= self.odometer_reading:
    21.             self.odometer_reading=mileage
    22.         else:
    23.             print("you can not roll back an odometer!")
    24.  
    25.     def increment_odometer(self, miles):
    26.         """将里程数增加指定的量"""
    27.         self.odometer_reading += miles
    28.  
    29.  
    30. class ElectricCar(Car):
    31.     """电动车的独特之处"""
    32.     def __init__(self, make, model, year):
    33.         """初始父类的属性"""
    34.         super().__init__(make, model, year)
    35.  
    36.  
    37. my_tesla = ElectricCar('tesla', 'models', 2022)
    38. print(my_tesla.get_descriptive_name())

    运行结果

    2022 Tesla Model

    6.3.2给子类定义属性和方法

    我们可以给子类 ElectricCart添加它自己的属性和方法：

    1. class Car:
    2.     """一次模拟汽车的简单尝试"""
    3.     def __init__(self, make, model, year):
    4.         self.make = make
    5.         self.model = model
    6.         self.year = year
    7.         self.odometer_reading = 0
    8.  
    9.     def get_descriptive_name(self):
    10.         """返回整洁的描述性信息"""
    11.         long_name = f"{self.year} {self.make} {self.model}"
    12.         return long_name.title()
    13.  
    14.     def read_odometer(self):
    15.         """读取里程数"""
    16.         print(f"this car's meter is {self.odometer_reading} miles on it")
    17.  
    18.     def update_odometer(self, mileage):
    19.         """将里程数设置为指定的值"""
    20.         if mileage >= self.odometer_reading:
    21.             self.odometer_reading = mileage
    22.         else:
    23.             print("you can not roll back an odometer!")
    24.  
    25.     def increment_odometer(self, miles):
    26.         """将里程数增加指定的量"""
    27.         self.odometer_reading += miles
    28.  
    29.  
    30. class ElectricCar(Car):
    31.     """电动车的独特之处"""
    32.     def __init__(self, make, model, year):
    33.         """初始父类的属性,再初始化电动汽车特有的属"""
    34.         super().__init__(make, model, year)
    35.         self.battery_size = 75
    36.  
    37.     def describe_battery(self):
    38.         """打印一条描述电瓶容量的消息"""
    39.         print(f"this car has a {self.battery_size} KWH battery")
    40.  
    41.  
    42. my_tesla=ElectricCar('tesla', 'models', 2022)
    43. print(my_tesla.get_descriptive_name())
    44. my_tesla.describe_battery()

    运行结果

    1. 2022 Tesla Models
    2. this car has a 75 KWH battery

    6.3.3将实例用作属性

    有时候我们需要给子类添加的细节（属性和方法）越来越多，这样的情况下，我们可以将类的一部分提取出来，作为一个独立的类。

    1. class Car:
    2.     """一次模拟汽车的简单尝试"""
    3.     def __init__(self, make, model, year):
    4.         self.make = make
    5.         self.model = model
    6.         self.year = year
    7.         self.odometer_reading = 0
    8.  
    9.     def get_descriptive_name(self):
    10.         """返回整洁的描述性信息"""
    11.         long_name = f"{self.year} {self.make} {self.model}"
    12.         return long_name.title()
    13.  
    14.     def read_odometer(self):
    15.         """读取里程数"""
    16.         print(f"this car's meter is {self.odometer_reading} miles on it")
    17.  
    18.     def update_odometer(self, mileage):
    19.         """将里程数设置为指定的值"""
    20.         if mileage >= self.odometer_reading:
    21.             self.odometer_reading = mileage
    22.         else:
    23.             print("you can not roll back an odometer!")
    24.  
    25.     def increment_odometer(self, miles):
    26.         """将里程数增加指定的量"""
    27.         self.odometer_reading += miles
    28.  
    29.  
    30. class Battery:
    31.     """一次模拟电动汽车的简单尝试"""
    32.     def __init__(self, battery_size=75):
    33.         """初始化电瓶的属性"""
    34.         self.battery_size = battery_size
    35.  
    36.     def describe_battery(self):
    37.         """打印一条描述电瓶容量的消息"""
    38.         print(f"this car has a {self.battery_size} KWH battery")
    39.  
    40.  
    41. class ElectricCar(Car):
    42.     """电动车的独特之处"""
    43.     def __init__(self, make, model, year):
    44.         """初始父类的属性,再初始化电动汽车特有的属性"""
    45.         super().__init__(make, model, year)
    46.         self.battery = Battery()
    47.  
    48.  
    49. my_tesla = ElectricCar('tesla', 'model ', 2022)
    50. print(my_tesla.get_descriptive_name())
    51. my_tesla.battery.describe_battery()

    运行结果

    1.  2022 Tesla Model 
    2. this car has a 75 KWH battery

    6.4导入类

    6.4.1导入单个类

    car.py

    1. """一个可用于表示汽车的类"""
    2.  
    3.  
    4. class Car():
    5.     """一次模拟汽车的简单尝试"""
    6.  
    7.     def __init__(self, make, model, year):
    8.         """初始化描述汽车的属性"""
    9.         self.make = make
    10.         self.model = model
    11.         self.year = year
    12.         self.odometer_reading = 0
    13.  
    14.     def get_descriptive_name(self):
    15.         """返回整洁的描述性名称"""
    16.         long_name = str(self.year) + ' ' + self.make + ' ' + self.model
    17.         return long_name.title()
    18.  
    19.     def read_odometer(self):
    20.         """打印一条消息，指出汽车的里程"""
    21.         print("This car has " + str(self.odometer_reading) + " miles on it.")
    22.  
    23.     def update_odometer(self, mileage):
    24.         """
    25.         将里程表读数设置为指定的值
    26.         拒绝将里程表往回拨
    27.         """
    28.         if mileage >= self.odometer_reading:
    29.             self.odometer_reading = mileage
    30.         else:
    31.             print("You can't roll back an odometer!")
    32.  
    33.     def increment_odometer(self, miles):
    34.         """将里程表读数增加指定的量"""
    35.         self.odometer_reading += miles

    my_car.py

    1. from car import Car
    2.  
    3. my_new_car = Car('audi', 'a4', 2022)
    4. print(my_new_car.get_descriptive_name())
    5.  
    6. my_new_car.odometer_reading = 23
    7. my_new_car.read_odometer()

    运行结果

    1. 2022 Audi A4
    2. This car has 23 miles on it.

    import语句让Python打开模块car，并导入其中的Car类。这样我们就可以使用Car类了，就像它是在这个文件中定义的一样。输出与我们在前面看到的一样。

    6.4.2在一个模块中存储多个类

    car.py

    1. """一个可用于表示汽车的类"""
    2.  
    3.  
    4. class Car():
    5.     """一次模拟汽车的简单尝试"""
    6.  
    7.     def __init__(self, make, model, year):
    8.         """初始化描述汽车的属性"""
    9.         self.make = make
    10.         self.model = model
    11.         self.year = year
    12.         self.odometer_reading = 0
    13.  
    14.     def get_descriptive_name(self):
    15.         """返回整洁的描述性名称"""
    16.         long_name = str(self.year) + ' ' + self.make + ' ' + self.model
    17.         return long_name.title()
    18.  
    19.     def read_odometer(self):
    20.         """打印一条消息，指出汽车的里程"""
    21.         print("This car has " + str(self.odometer_reading) + " miles on it.")
    22.  
    23.     def update_odometer(self, mileage):
    24.         """
    25.         将里程表读数设置为指定的值
    26.         拒绝将里程表往回拨
    27.         """
    28.         if mileage >= self.odometer_reading:
    29.             self.odometer_reading = mileage
    30.         else:
    31.             print("You can't roll back an odometer!")
    32.  
    33.     def increment_odometer(self, miles):
    34.         """将里程表读数增加指定的量"""
    35.         self.odometer_reading += miles
    36.  
    37.  
    38. class Battery():
    39.     """一次模拟电动汽车电瓶的简单尝试"""
    40.  
    41.     def __init__(self, battery_size=70):
    42.         """初始化电瓶的属性"""
    43.         self.battery_size = battery_size
    44.  
    45.     def describe_battery(self):
    46.         """打印一条描述电瓶容量的消息"""
    47.         print("This car has a " + str(self.battery_size) + "-kWh battery.")
    48.  
    49.     def get_range(self):
    50.         """打印一条描述电瓶续航里程的消息"""
    51.         if self.battery_size == 75:
    52.             range = 260
    53.         elif self.battery_size == 100:
    54.             range = 315
    55.         message = "This car can go approximately " + str(range)
    56.         message += " miles on a full charge."
    57.         print(message)
    58.  
    59.  
    60. class ElectricCar(Car):
    61.     """模拟电动汽车的独特之处"""
    62.  
    63.     def __init__(self, make, model, year):
    64.         """
    65.         初始化父类的属性，再初始化电动汽车特有的属性
    66.         """
    67.         super().__init__(make, model, year)
    68.         self.battery = Battery()

    my_electric_car.py

    1. from car import ElectricCar
    2.  
    3. my_tesla = ElectricCar('tesla', 'model s', 2016)
    4.  
    5. print(my_tesla.get_descriptive_name())
    6. my_tesla.battery.describe_battery()
    7. my_tesla.battery.get_range()

    我们新建了一个名为my_electric_car.py的文件，导入ElectricCar类，并创建一辆电动汽车。

    6.4.3从一个模块中导入多个类

    my_car.py

    1. from car import Car, ElectricCar
    2.  
    3. my_beetle = Car('volkswagen', 'beetle', 2022)
    4. print(my_beetle.get_descriptive_name())
    5.  
    6. my_tesla = ElectricCar('tesla', 'roadster', 2023)
    7. print(my_tesla.get_descriptive_name())

    结合前文my_electric_car.py文件和car.py文件，运行my_car.py，结果如下

    1. 2022 Volkswagen Beetle
    2. 2023 Tesla Roadster

    6.4.4导入整个模块

    你还可以导入整个模块，再使用句点表示法访问需要的类。这种导入方法很简单，代码也易于阅读。由于创建类实例的代码都包含模块名，因此不会与当前文件使用的任何名称发生冲突。
    下面的代码导入整个car模块，并创建一辆普通汽车和一辆电动汽车。

    对my_car.py文件进行修改，

    my_car.py

    1. import car
    2.  
    3. my_beetle = car.Car('volkswagen', 'beetle', 2022)
    4. print(my_beetle.get_descriptive_name())
    5.  
    6. my_tesla = car.ElectricCar('tesla', 'roadster', 2023)
    7. print(my_tesla.get_descriptive_name())
    8.

    结合前文my_electric_car.py文件和car.py文件，运行my_car.py，结果如下

    1. 2022 Volkswagen Beetle
    2. 2023 Tesla Roadster

    6.4.5导入模块的所有类

    frommodule_name import *

    6.5类型注解

    注意：类型注解知识提示性的，并非决定性的。数据类型和注解类型无法对应也不会报错。

    6.5.1变量的类型注释

    类型注解主要功能在于：

    帮助第三方IDE工具（如PyCharm）对代码进行类型推断，帮助做代码提示

    帮助开发者自身对变量进行类型注释（备注）

    1. import random
    2. """
    3. 演示变量的类型注解
    4. """
    5.  
    6.  
    7. # 基础数据类型注解
    8. var_1: int = 10
    9. val_2: str = "xuan"
    10. var_3: bool = True
    11. # 类对象类型注解
    12.  
    13.  
    14. class Student:
    15.     pass
    16.  
    17.  
    18. stu: Student = Student()
    19. # 基础容器类型注解
    20. my_list: list = [1, 2, 3]
    21. my_tuple: tuple = (1, 2, 3)
    22. my_dict: dict = {"xuan": 26}
    23. # 容器类型注解
    24. my_list1: list[int] = [1, 2, 3]
    25. my_tuple1: tuple[int, str, bool] = (1, "hello", True)
    26. my_dict1: dict[str, int] = {"xuan": 26}
    27. # 在注释中进行类型注解
    28. var_4 = random.randint(1, 10)   # type: int
    29.  
    30.  
    31. def func():
    32.     return 10
    33.  
    34.  
    35. var_5 = func()  # type: int

    6.5.2函数和方法类型注解

    鼠标放到括号里，按ctrl+p，就会有提示 

    1. # 对形参进行类型注解
    2. def add(x: int, y: int):
    3.     return x + y
    4.  
    5.  
    6. #  对返回值进行类型注解
    7. def func(data: list) -> list:
    8.     return data

    6.5.3Union联合类型注解

     

    1. # 示意Union类型，必须先导包
    2. from typing import Union
    3.  
    4. my_list: list[Union[int, str]] = [1, 2, "xuan", "feng"]
    5.  
    6.  
    7. def func(data: Union[int, str])-> Union[int, str]:
    8.     pass
    9.  
    10. func()
  • 相关阅读:
    字符编码原理的理解
    rust多个mod文件引用和文件夹mod使用注意事项
    Java：关于mybatis框架mapper.xml编写小于号＜的问题
    Mybatis架构原理(二)-二级缓存源码剖析
    Keras 3.0发布：全面拥抱 PyTorch！
    C. Omkar and Baseball
    私有云盘Nextcloud在线解压开发（瞎搞瞎搞0.0）
    腾讯云4核8G12M服务器支持多少人在线？
    修改origin分支名
    Linux下gz和tar.gz、与Windows天zip压缩解压
  • 原文地址：https://blog.csdn.net/Xx_Studying/article/details/126385428