《Python从入门到实践》学习笔记

第二章、变量和简单的数据类型

1.修改字符串的大小写

  1. name = headong
  2. name = name.title()
  3. print(name)
  4. #title()函数，把单词的首字母变成大写
  7. #将所有的字符串变成大写
  8. print(name.upper())
  9. #将所有的字符串变成小写
  10. print(name.lower())

2.制表符和换行

  • 制表符tab：\t
  • 换行符：\n

3.删除空白

strip():删除字符串开头和末尾多余的空白

  1. #strip()删除字符串开头和末尾多余的空白
  2. #lstrip()删除开头的空白
  3. #rstrip()删除末尾的空白

第三章、列表

1.修改列表中的元素

  • 在列表中插入元素
  1. #列表名.insert(要插入的位置,元素的内容)
  2. he = ['a','b','c']
  3. he.insert(0,'d')
  4. print(he)

  • 删除列表元素

    • 方法一：删除指定所以的元素

      • del 列表名[索引]

    • 方法二：出栈——将列表末尾的元素移除并作为返回值返回

      • 列表名.pop()

    • 方法三：删除列表的指定元素

      • 列表名.remove(指定元素)
      • ==注意：==我们使用完remove函数后，该元素后面的所有元素索引-1

```python

一、del 列表名(索引)

del he[0]

二、使用pop()将列表末尾的元素弹出(返回值是列表末尾的元素)

moto = [‘honda’,’yama’,’suzuki’] print(moto) popped = moto.pop() print(moto) print(popped)

  4. <a name="695ce77e"></a>
  5. #### 2.排序
  8. > - 将列表中的元素按照首字母表排序
  10. > ```python
  11. #列表名.sort()
  • 按照与字母顺序相反的序列排列
  1. #列表名.sort(reverse = True)
  • 按照特定的顺序呈现列表，但是保持原来的索引序列
  1. car = ['bmw','audi','toyota','subaru']
  2. print('这是最开始的列表的样子！')
  3. print(car)
  4. print('这是使用临时该表列表顺序后的样子！')
  5. print(sorted(car))
  6. print('再看看列表的序列有没有改变')
  7. print(car)

  • sorted()

    • 将列表中的元素的索引序列颠倒（与元素的内容无关，只是单纯将现在的列表反转）

3.确定列表的长度

  1. len(列表名)
  2. #有几个元素就会输出几

4.索引-1代表列表的最后一个元素

第四章、操作列表

  • 使用range()创建数字列表
  • range()函数可以设置步长

```python

list()函数：将其括号里的参数转化为列表

number = list(range(1,6))

使用range()设置步长

从2开始数，不断加3，知道达到或者超过11S

number = list(range(2, 11, 3))

  2. > - 找到列表里最大的元素，最小的元素，列表元素的总和
  4. > ```python
  5. digits - [1, 2, 3, 4, 5, 6]
  6. min(digits)
  7. max(digits)
  8. sum(digits)

```python squares = [value**2 for value in range(1,11)]

上面的式子等价于

squares = [] for value in range(1, 11): squares.append(value**2)

  4. <a name="bae4c5a3"></a>
  5. ### 1.列表的切片
  8. > ```python
  9. print(player[1, 4])
  10. #这个切片最终输出的元素为索引1~3的元素
  11. #注意：1.包前不包后
  12. #     2.如果没有指定索引则默认从开头开始
  13. #     3.如果没有指定后面的元素，同理 
  14. print(player[:4])

2.复制列表

复制列表的方法：

  • 使用==[:]==(切片)

    1. my_food = ['pizza','falafel','carrot cake']
    2. friend_food = my_food[:]
    3. my_food.append('豆浆')
    4. friend_food.append('胡辣汤')
    5. print(friend_food)
    6. print(my_food)

  • 为什么不能用原列表直接赋值给新的列表？

    • 直接赋值知识将新列表名同时指向了同一个列表
    • 没有将旧列表的副本存储到新列表中

3.元组

  • 我们不能修改元组的元素
  • 如果要修改元素元素的话，只能给元组重新赋值

4.设置代码格式

第五章、if语句

  • 单等号和双等号的区分

```python

一个等号代表陈述：将变量car的值设置为’audi’

car = ‘audi’

两个等号表示发问：变量car的值是’bmw’吗？

car == ‘bmw’

  2. > - 双等号检查时，会区分大小写
  6. <a name="c7cc766d"></a>
  7. ## `六、字典`
  10. > - 往字典里面添加元素
  12. > ```python
  13. a = {}
  14. a['color'] = 'green'
  15. a['number'] = 10
  16. print(a)
  • 删除键值对
  1. del a['color']
  2. #使用del语句直接删除该键值对

一、遍历字典

Python有三种遍历字典的方式

  • 遍历键——值对
  • 遍历键
  • 遍历值

1、遍历键——值对

  • 使用for循环来遍历列表

```python user = { ‘username’:’efermi’, ‘first’:’enrico’, ‘last’:’fermi’ }

下面是遍历的代码

for key, value in user.items(): print(“\nKey:” + key) print(“Value:” + value)

  2. > - items()
  4. >    - `返回：`返回一个键值对列表
  6. > - ==注意：==for后面的也是两个变量，这两个变量的名字可以根据我们具体的使用环境来具体定义
  10. <a name="25e1b902"></a>
  11. #### 2、遍历字典中所有的键
  14. > ```python
  15. user = {
  16.    'age':12,
  17.    'favourite':'basketball',
  18.    'fruit':'apple'
  19. }
  20. #依次返回字典的键，并把这个键保存到变量name中
  21. for name in user.keys():
  22.    print(name.title())
  • keys()
  • 返回：这个函数只返回字典的键（这些键组成了一个列表），而不返回值（只有字典才可以被for循环所遍历）

3、遍历字典中所有的值

  • values()

    • 返回：这个函数只返回字典的值（这些值组成了一个列表）

4、set集合

什么是集合(set):集合类似于列表，但是每个元素都必须是独一无二的

  • set()函数：对一个列表使用set()函数，返回一个每隔元素都不会重复的列表
  • 作用：对列表中的元素进行去重

二、嵌套

什么是嵌套：

将一系列字典存储在列表中，或者将列表存储在字典中，就叫做嵌套。

1、字典存在列表

什么时候需要把列表存在字典中？

  • 列表中需要包含很多个字典，并且这些字典的结构很类似（都拥有相同的键但不同的值）
  • 比如游戏中的障碍物（他们都要不断出现，并且拥有类似的结构）
  • 比如在网页中要创建一个用户列表

2、列表存在字典

什么时候需要把列表存在字典中？

  • 当需要在字典中将一个键关联到多个值时，在字典中嵌套一个列表。

3、在字典中存储字典

什么时候使用在字典中存储字典？

  • 当我们要存储多个不同id用户的信息，这些用户还有着相同的属性结构时使用
  1. users = {
  2.     '张三':{
  3.         '爱好':'basketball',
  4.         '性别':'男',
  5.         '地址':'西安'
  6.     },
  7.     '李四':{
  8.         '爱好':'sing',
  9.         '性别':'女',
  10.         '地址':'西安'
  11.     }
  12. }

4、

  1. laoda = {
  2.     'zhuren':'zhangsan',
  3.     'maose':'yellow'
  4. }
  5. laoer = {
  6.     'zhuren':'lisi',
  7.     'maose':'green'
  8. }
  9. pets = [老大,laoer]
  11. for pet in pets:
  12.     print('毛色是'+pet['maose']+'的pet，它的主人是'+pet['zhuren'])

第七章、用户输入和while循环

一、函数input( )

参数：

  • input()只接受一个参数，就是让用户可以看见的，提醒用户输入的话。

  • 如果要提示用户的话比较长，或者分为几行？

    • 把要展示的内容存储在变量中

      1. prompt = '这是第一行。'
      2. prompt += '\n你要输出啥呢？'

+Python将用户的输入识别为字符串

  • 如果想输入数字，并且数据类型也为整型怎么办？
  • ==int()==函数将输入转化为整型

二、使用while循环

  • 一定要避免死循环

三、使用标志切换程序状态

  1. prompt = '程序要quit还是打印别的东西呢？'
  2. active = True
  3. #在下面这个循环中，当我们输如quit时，active的状态被修改成了False,这是退出while循环
  4. while active:
  5.     message = input(prompt)
  6.     if message == 'quit':
  7.         active = False
  8.     else:
  9.         print(message)

四、break和continue

1、break语句

退出当前循环(应该是退出距离break最近一层的循环)

2、continue语句

  1. #完成功能：从1输出到10，但是，只输出其中的奇数，不输出偶数
  2. current_number = 0
  3. while current_number < 0:
  4.     current_number += 1
  5.     if current_number % 2 == 0:
  6.         continue
  7.     print(current_number)
  • continue语句执行后，循环中continue后面的代码不再执行，直接跳过，返回到循环开始
  • 在上面的例子中：当current_number为2时，第六行执行，第7行直接背跳过，回到循环开始

习题

7-4

  1. message = '请您输入您所需要的配料：'
  2. message += '\n要退出输入，输入quit即可'
  4. active = True
  5. while active:
  6.     food = input(message)
  7.     if food == 'quit':
  8.         print('输入结束')
  9.         active = False
  10.     else:
  11.         print(food)

五、用while循环来遍历列表和字典

  1. while 列表:
  2.     循环体

原则：

  • 当列表不为空时，while循环一直执行
  • 当列表为空时，while循环停止

```python unuser = [‘a’,’b’,’c’] user = []

验证每个用户，直到没有未验证的用户为止

将每个验证的列表都移动到已验证的用户列表中

while unuser:

  1. #使用pop函数，把为验证列表的最后一个元素弹出，放在变量current_user中
  2. current_user = unconfirmed_user.pop()
  3. print('正在验证用户：' + current_user)
  4. #使用append函数把刚才验证过的用户添加到已验证列表中
  5. user.append(current_user)

print(‘现在已经验证的用户都有：’) for cuser in user: print(cuser.title())

  4. <a name="52676027"></a>
  5. #### 1.使用while循环删除列表中的指定元素
  7. ```python
  8. #while 要删除的元素 in 列表：
  9. #    列表名.remove(要删除的元素)
  11. foods = ['甜甜圈','鸡肉卷','鸡肉卷','蛋挞','披萨']
  12. while '鸡肉卷' in foods:
  13.     foods.remove('鸡肉卷')
  15. print(foods)

原理：

只要要删除的元素还在列表里面，while循环就会不断执行，直到列表中没有我们要删除的元素。

过程：先做判断看鸡肉卷是不是在foods里，然后执行remove函数。

  1.          执行完后再判断鸡肉卷是不是在foods里，如果在，执行remove函数，
  3.          如果不在，退出循环，指定元素已经删除结束。

2.使用用户输入来填充字典

  • 还是要使用标志来切换状态，再加上字典就可以啦

7-8

  1. sandwich_orders = ['烧饼','梅干菜扣肉饼','囊饼']
  2. finished_sandwiches = []
  4. while sandwich_orders:
  5.     eat = sandwich_orders.pop()
  6.     print('我现在正在吃：'+ eat)
  7.     finished_sandwiches.append(eat)
  9. for i in finished_sandwiches:
  10.     print(i + '我已经吃完了！')

第八章、函数

一、定义函数

  1. #定义函数
  2. def 函数名():
  3.     函数体
  4. #使用函数
  5. 函数名()

函数名命名的注意点：

  • 遵从变量命名的要点

    • 不能数字开头
    • 小驼峰命名发

1.实参和形参

```python def dong(name): print(‘我的名字是’ + name)

dong(‘hehe’)

  2. > **`形参：`**在上面的定义函数的代码中， 括号里的那个参数没有真实的含义，只是让大家知道，这里应该放一个参数。
  4. > **`实参：`**在上面使用函数的代码中，括号里面传入的字符串就是实参，这个参数被存放在形参name中。
  7. <a name="cbf69155"></a>
  8. #### 2.位置实参
  10. > 故名思意，传入实参的位置要与我们定义的形参的位置所对应，这个也是我们最常见的传参方式，再此不多做解释。
  13. <a name="7b5eca76"></a>
  14. #### 3.关键字实参
  16. > **不考虑闯入参数时实参的顺序**：我们在传入的时候，就对指定的形参指定具体的值，这样就不用顾及传入参数的顺序啦。
  18. > ```python
  19. def dong(name, age, city):
  20.     print('来自' + city '的' + name + '今年已经' + age '岁了')
  22. #位置实参的方式传入参数，需要注意参数的位置
  23. dong('张三', 13, '北京')
  25. #关键字实参传入参数，不需要注意参数的位置，就算传入时位置与形参不同，也不影响输出结果
  26. dong(age=13, city='上海', name='李四')

4.默认值

作用：我们在定义函数的时候可以给一些参数设置默认值，在后面调用函数的时候，我们如果没有给设定了默认值的参数赋值，那么这个参数的值就是默认值。

  • 默认值参数在定义时一般放在末尾，因为，我们一般使用的时位置实参
  • 设置了默认值的参数在调用时可以不给这个参数赋值
  • 没有设置默认值的参数，在调用时必须给相关的参数赋值，不然会报错

二、返回值

三、传递列表

1.在函数中修改列表

将列表传递给函数后，函数就可以对列表进行修改。

而且在函数中对这个列表所做的所有的操作都是永久的。

注意：如果列表是全局变量，若它不以参数的形式传入函数，他是不能在函数里面修改的。

  1.           若它以参数的形式传入函数，它是可以被修改的。

2.禁止函数修改列表

方法：将列表得副本传递给函数

  1. function_name(list_name[:])
  2. #使用函数名[:]切片的方式，就可以获得列表得副本

8——10

  1. def show_magicians(name, greatname):
  2.     while name:
  3.         current_name = name.pop()
  4.         a ='the ' + 'Great' + current_name
  5.         print(a)
  6.         greatname.append(a)
  8. name_list = ['张三','李四','王五','赵六']
  9. greatname = []
  10. show_magicians(name_list[:],greatname)
  11. print(name_list)
  12. print(greatname)

四、传递任意数量的实参

问题：预先不知道要传入几个参数怎么办？

解决：使用*name，创建了一个名字叫做name的元组，所有收到的实参都会放在这个元组里面。

(无论传入多少个参数都可以)

  1. def 函数名(*name):

1.混合使用参数

要点：把任意参数放在定义的形式参数的最后面，就像下面这样

  1. def 函数名(can1, can2, can3, *name):

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

问题：在上面我们可以向函数中传入任意数量的参数，但是我们不知道，我们传入的这些参数具体代表是么意思，有什么用途，这怎么办？

解决：

  • 传入参数时，要求用户传入键值对，以用来对传入的参数进行解释。
  • **name：代表往函数中传入任意数量的键值对。

```python def build_profile(first, last, **user_info):

  1. #形参**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

user_profile = build_profile(‘albert’, ‘einstein’, location = ‘princenton’, field = ‘physics’) print(user_prfile000)

  4. <a name="0840ca53"></a>
  5. ### 五、将函数存储在模块中
  7. <a name="d84244f6"></a>
  8. #### 1.导入模块的三种方式
  10. - import 模块名
  11. - from 模块名 import *
  13.    - 导入该模块中的所有函数
  14. - from 模块名 import 函数名
  16.    - 导入该模块中的某个函数
  18. <a name="41942cc8"></a>
  19. #### 2.使用as给模块和函数重命名
  21. - 
  22. from 模块名 import  函数名 as 新的函数名
  24. - 
  25. import 模块名 as 新的模块名
  28. <a name="f45611c3"></a>
  29. ## `第九章、类`
  31. <a name="830fc9d6"></a>
  32. ### 一、创建和实用类
  34. ```python
  35. #创建狗类
  36. class Dog():
  37.     def _init_(self, name, age):
  38.         #初始化属性name和age
  39.         self.name = name
  40.         self.age = age
  41.     def sit(self):
  42.         #模拟小狗被命令蹲下
  43.         print(self.name.title()+' is now sitting')
  44.     def roll_over(self):
  45.         #模拟小狗被命令时打滚
  46.         print(self.name.title()+ " rolled over!")

1.方法__init__()

方法：类中的函数称为方法。

__init__()当我们根据类创建新实例时，Python都会自动执行这个函数。

self

  • 是一个指向实例本身的引用，让实例能够访问类中的属性和方法
  • 以self为前缀的变量都可供类中的所有方法使用，我们还可以通过类的任何实例来访问这些变量

属性

  • 在类中可以通过self直接访问的变量

    1. self.name = name

二、创建实例

  1. my_dog = Dog('willie', 6)
  2. print('我的狗的名字是' + my_dog.name.title() + '.')
  3. my_dog.sit()

2.1 访问属性 & 调用方法

采用句点 ==.==表示法

  1. my_dog.name
  2. '''
  3. my_dog是实例
  4. name是实例中的属性
  5. '''
  6. my_dog.sit()
  7. #sit()是方法

类创建好以后就可以创建多个实例了

2.2 给属性指定默认值

  1. class Car():
  2.     '''模拟汽车'''
  3.     def __init__(self, make, model, year):
  4.         '''初始化汽车的属性'''
  5.         self.make = make
  6.         self.model = model
  7.         self.year = year
  8.         #在这个给历程属性默认值
  9.         self.odometer_reading = 0
  10.     def get_descriptive_name(self):
  11.         long_name = str(self.year) + ' ' + self.make + '' + self.model
  12.         return long_name.title()
  13.     def red_odometer(self):
  14.         '''打印一条指出汽车历程的信息'''
  15.         print('这辆汽车一共走了' + self.odometer + '公里了!')
  17. #在定义类时，直接给属性赋值就行

2.3 三种修改属性值的方式

2.3.1 直接修改属性的值
  1. new_car('audi', 'a4', 2016)
  2. #直接通过实例访问属性，然后修改属性的值就行
  3. new_car.odometer_reading = 23

2.3.2 通过方法修改属性的值

定义一个方法，通过这个方法修改属性的值

  1. class Car():
  2.     --snip--
  3.     def update_odometer(self, mileage):
  4.         if mileage >= self.odometer_reading:
  5.             #这个函数用来给历程数指定特定的值
  6.             self.odometer_reading = mileage
  7.         else:
  8.             print('You can not roll back an odometer!')

2.3.3 通过方法对属性的值进行递增
  1. class Car():
  2.     --snip--
  3.     def update_odometer(self, mileage):
  4.         --snip--
  5.     def increment_odometer(self, miles):
  6.         #将里程表读数增加指定的量
  7.         sefl.odometer_reading += miles

三、继承

什么时候继承？

  • 编写的类是另一个现成类的特殊版本，可使用继承。

继承的特点：

  • 一个类继承另一个类时，它将自动获得另一个类的所有属性和方法
  • 子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法
  • 原来的类称为父类，新的类称为子类
  1. class ElectricCar(Car):
  2.     '''电动车特有的地方'''
  3.     def __init__(self, make, model, year):
  4.         '''初始化父类的属性'''
  5.         super().__init__(make, model, year)

注意：

  • 创建子类时，父类必须包含在同一个文件中，且得在子类的前面
  • 定义子类是，必须在括号里指定父类的名称
  • 方法init()接受创建Car实例所需要的信息
  • super()这个函数，让子类实例包含父亲的所有属性
  • 父类也称之为超类，因此也名为super

3.1 给子类定义属性和方法

定义子类特有的方法

  1. class Car():
  2.     --snip--
  4. class ElectricCar(Car):
  5.     def __init__(self, make, model, year):shuxb
  6.         '''
  7.         电动汽车的独特之处
  8.         初始化父类属性，再初始化电动车特有属性
  9.         '''
  10.         super().__init__(make, model, year)
  11.         #在这里定义了一个新的属性
  12.         self.battery_size = 70
  13.     def describe_battery(self):
  14.         #打印一条描述电瓶容量的消息
  15.         print('这辆车的电瓶容量是'+str(self.battery_size))

3.2 重写父类的方法

为什么要重写父类方法？

  • 如果父类的方法不符合子类模拟的事物的行为，则对其进行重写

如何重写？

  • 在子类中定义一个与父类同名的方法，在运行时Python就会优先考虑子类中重写的方法

重写的意义？

  • 能让子类对父类进行取其精华，弃其糟粕

3.3 将大类拆分成小类

  • 比如前面电动车中，电瓶有关的方法和属性很多，就可以把电瓶相关的内容摘出去，单独作为一个类
  1. #这是最开始的父类
  2. class Car():
  3.     --snip--
  6. class Battery():
  7.     '''一次模拟电瓶车的简单尝试'''
  8.     def __init__(self, battery_size = 70):
  9.         self.battery_size = battery_size
  10.     def describe_battery(self):
  11.         #打印一条描述电瓶容量的消息
  12.         pring('这辆车的电瓶容量是'+str(self.battery_size))
  14. classs Ecar():
  15.     '''这是一个电动车的类'''
  16.     def __init__(self, make, model, year):
  17.         '''初始化父类属性，再初始化电动车特有的属性'''
  18.         super().__init__(make, model, year)
  19.         self.battery = Battery()

四、导入类

  1. #方法1
  2. import 模块名
  3. '''
  4. 这种方法在后面使用模块中方法和属性的时候
  5. 要在前面加上类名
  6. 比如下面这种格式：
  7. '''
  8. Dog.my_dog.sit()
  10. #方法2
  11. from 模块名 import 类名
  12. '''
  13. 这种方法导入模块中指定的类
  14. 在后面编写代码的时候，不需要写类名
  15. '''
  17. #方法3
  18. from 模块名 import 类名
  19. '''
  20. 导入模块中的所有类
  21. 在后面编写代码时，不需要写类名
  22. '''

第十章 文件和异常

一、从文件中读取数据

1.1 读取整个文件

  • open(文件的名称)函数

    • 作用：打开文件，所有对文件进行操作的第一步
    • 参数文件的名称要以字符串的形式传入

  • with关键字

    • 无论 with 中的代码块在执行的过程中发生任何情况(就算有bug)，文件最终都会被自动关闭。

  • read()方法

    • 读取这个文件的全部内容，将其作为一个常字符串返回

    • read()到达文件末尾时返回一个空字符串，这个空字符串显示出来就是一个空行

      • 对contents变量使用.rstrip()函数删除最后的空行
  1. with open('pi_digits.txt') as file_object:
  2.     contents = file_object.read()
  3.     #rstrip()函数删除空行
  4.     print(contents.rstrip())

1.2 文件路径

  • 相对路径

    • 文件相对于正在编写的.py文件的位置

  • 绝对路径

    • 文件在电脑中的具体位置
    • ‘C:\User\adogn\other_files\text_files\filename.txt’
    • 注意在windows系统中用的是反斜杠

1.3 创建一个包含文件各行内容的列表

  • 如果不将内容保存在列表或变量中，文件的内容只可在with结构内可用
  • 保存在列表以后，在with结构后面也可以对文件内容进行操作

  • readlines()函数

    • 从文件中读取每一行，并将每一行作为一个元素存储在列表中，文件整体都存在一个列表中
  1. filename = 'pi_digits.txt'
  2. with open(filename) as file_object:
  3.     lines = file_object.readlines()
  5. for line in lines:
  6.     print(line.rstrip())

1.4 使用文件中的内容

  1. filename = 'pi_digits.txt'
  2. with open(filename) as file_object:
  3.     lines = file_object.readlines()
  4. pi_string = ''
  5. for line in lines:
  6.     pi_string += line.restrip()
  7. print(pi_string)
  8. print(len(pi_string))