python笔记

pythinpython笔记

一、基础语法

1、单行注释(行注释)：

以 # 开头，# 右边的所有东西都被当做说明文字

2、多行注释：

要在 Python 程序中使用多行注释，可以用 一对 连续的 三个 引号(单引号和双引号都可以)

3、算数运算符

// 取整除 返回除法的整数部分（商） 9 // 2 输出结果 4

% 取余数 返回除法的余数 9 % 2 = 1

** 幂 又称次方、乘方，2 ** 3 = 8

4、type(name)

Python`中定义变量时不需要指定类型

使用 type 函数可以查看一个变量的类型

5、 重复拼接相同的字符串

字符串变量** 可以和 整数 使用 * 重复拼接相同的字符串

6、变量的输入

要获取用户在 键盘 上的输入信息，需要使用到 input 函数

7、类型转换函数

函数	说明
int(x)	将 x 转换为一个整数
float(x)	将 x 转换到一个浮点数

8、变量的格式化输出

格式化字符	含义
%s	字符串
%d	有符号十进制整数，%06d 表示输出的整数显示位数，不足的地方使用 0 补全
%f	浮点数，%.2f 表示小数点后只显示两位
%%	输出 %

• 语法格式如下：

  print(“我的名字叫 %s，请多多关照！” % name)
  print(“我的学号是 %06d” % student_no)
  print(“苹果单价 %.02f 元／斤，购买 %.02f 斤，需要支付 %.02f 元” % (price, weight, money))
  print(“数据比例是 %.02f%%” % (scale * 100))

9、变量的命名

• 标示符可以由 字母、下划线 和 数字 组成

• 不能以数字开头

• 不能与关键字重名

  通过以下命令可以查看 Python 中的关键字

  In [1]: import keyword
  In [2]: print(keyword.kwlist)
  

  注意Python 中的 标识符 是 区分大小写的

10、if语句

在 Python 开发中，Tab 和空格不要混用！

**if和else` 语句以及各自的缩进部分共同是一个 **完整的代码块

11、逻辑运算

and / or/ not

12、随机数的处理

• 在 Python 中，要使用随机数，首先需要导入 随机数 的 模块 —— “工具包”

import random

• 导入模块后，可以直接在 模块名称 后面敲一个 . 然后按 Tab 键，会提示该模块中包含的所有函数
• random.randint(a, b) ，返回 [a, b] 之间的整数，包含 a 和 b
• 例如：

random.randint(12, 20)  # 生成的随机数n: 12 <= n <= 20   
random.randint(20, 20)  # 结果永远是 20   
random.randint(20, 10)  # 该语句是错误的，下限必须小于上限

13、while` 循环

i = 1
while i <= 5:
    print("Hello Python")
    i = i + 1

print("循环结束后的 i = %d" % i)

14/转义字符

制表符 的功能是在不使用表格的情况下在 垂直方向 按列对齐文本

转义字符	描述
\\	反斜杠符号
\’	单引号
\"	双引号
\n	换行
\t	横向制表符
\r	回车

15、函数封装定义

def

def say_hello():
    print("hello 1")

注意：因为 函数体相对比较独立，函数定义的上方，应该和其他代码（包括注释）保留 两个空行

16、导入模块

import

import hm_10_分隔线模块

hm_10_分隔线模块.print_line("-", 80)
print(hm_10_分隔线模块.name)

17、 Pyc 文件

18、列表（数组）

| | | 列表.append(数据) | 在末尾追加数据
| | | 列表.extend(列表2) | 将列表2 的数据追加到列表 |
| 2 | 修改 | 列表[索引] = 数据 | 修改指定索引的数据 |
| 3 | 删除 | del 列表[索引] | 删除指定索引的数据 |
| | | 列表.remove[数据] | 删除第一个出现的指定数据 |
| | | 列表.pop | 删除末尾数据 |
| | | 列表.pop(索引) | 删除指定索引数据 |
| | | 列表.clear | 清空列表 |
| 4 | 统计 | len(列表) | 列表长度 |
| | | 列表.count(数据) | 数据在列表中出现的次数 |
| 5 | 排序 | 列表.sort() | 升序排序 |
| | | 列表.sort(reverse=True) | 降序排序 |
| | | 列表.reverse() | 逆序、反转 |

19、循环遍历数组

for name in name_list:

    循环内部针对列表元素进行操作
    print(name)

20、元组

元组）与列表类似，不同之处在于元组的 元素不能修改

元组用 () 定义

info_tuple = (“zhangsan”, 18, 1.75)

元组中 只包含一个元素 时，需要 在元素后面添加逗号

元组和列表之间的转换

• 使用 list 函数可以把元组转换成列表

list(元组) 

• 使用 tuple 函数可以把列表转换成元组

tuple(列表)

21、字典

就是json

方法

In [1]: xiaoming.
xiaoming.clear       xiaoming.items       xiaoming.setdefault
xiaoming.copy        xiaoming.keys        xiaoming.update
xiaoming.fromkeys    xiaoming.pop         xiaoming.values
xiaoming.get         xiaoming.popitem   

22、字符串

方法

In [1]: hello_str.
hello_str.capitalize    hello_str.isidentifier  hello_str.rindex
hello_str.casefold      hello_str.islower       hello_str.rjust
hello_str.center        hello_str.isnumeric     hello_str.rpartition
hello_str.count         hello_str.isprintable   hello_str.rsplit
hello_str.encode        hello_str.isspace       hello_str.rstrip
hello_str.endswith      hello_str.istitle       hello_str.split
hello_str.expandtabs    hello_str.isupper       hello_str.splitlines
hello_str.find          hello_str.join          hello_str.startswith
hello_str.format        hello_str.ljust         hello_str.strip
hello_str.format_map    hello_str.lower         hello_str.swapcase
hello_str.index         hello_str.lstrip        hello_str.title
hello_str.isalnum       hello_str.maketrans     hello_str.translate
hello_str.isalpha       hello_str.partition     hello_str.upper
hello_str.isdecimal     hello_str.replace       hello_str.zfill
hello_str.isdigit       hello_str.rfind

提示：正是因为 python 内置提供的方法足够多，才使得在开发时，能够针对字符串进行更加灵活的操作！应对更多的开发需求！

1) 判断类型 - 9

方法	说明
string.isspace()	如果 string 中只包含空格，则返回 True
string.isalnum()	如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True
string.isdecimal()	如果 string 只包含数字则返回 True，全角数字
string.isdigit()	如果 string 只包含数字则返回 True，全角数字、⑴、\u00b2
string.isnumeric()	如果 string 只包含数字则返回 True，全角数字，汉字数字
string.istitle()	如果 string 是标题化的(每个单词的首字母大写)则返回 True
string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True

2) 查找和替换 - 7

方法	说明
string.startswith(str)	检查字符串是否是以 str 开头，是则返回 True
string.endswith(str)	检查字符串是否是以 str 结束，是则返回 True
string.find(str, start=0, end=len(string))	检测 str 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 -1
string.rfind(str, start=0, end=len(string))	类似于 find()，不过是从右边开始查找
string.index(str, start=0, end=len(string))	跟 find() 方法类似，不过如果 str 不在 string 会报错
string.rindex(str, start=0, end=len(string))	类似于 index()，不过是从右边开始
string.replace(old_str, new_str, num=string.count(old))	把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次

3) 大小写转换 - 5

方法	说明
string.capitalize()	把字符串的第一个字符大写
string.title()	把字符串的每个单词首字母大写
string.lower()	转换 string 中所有大写字符为小写
string.upper()	转换 string 中的小写字母为大写
string.swapcase()	翻转 string 中的大小写

4) 文本对齐 - 3

方法	说明
string.ljust(width)	返回一个原字符串左对齐，并使用空格填充至长度 width 的新字符串
string.rjust(width)	返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串
string.center(width)	返回一个原字符串居中，并使用空格填充至长度 width 的新字符串

5) 去除空白字符 - 3

方法	说明
string.lstrip()	截掉 string 左边（开始）的空白字符
string.rstrip()	截掉 string 右边（末尾）的空白字符
string.strip()	截掉 string 左右两边的空白字符

6) 拆分和连接 - 5

方法	说明
string.partition(str)	把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面)
string.rpartition(str)	类似于 partition() 方法，不过是从右边开始查找
string.split(str="", num)	以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 ‘\r’, ‘\t’, ‘\n’ 和空格
string.splitlines()	按照行(’\r’, ‘\n’, ‘\r\n’)分隔，返回一个包含各行作为元素的列表
string.join(seq)	以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串

23/字符串的切片

演练需求

• 1. 截取从 2 ~ 5 位置 的字符串
• 2. 截取从 2 ~ 末尾 的字符串
• 3. 截取从 开始 ~ 5 位置 的字符串
• 4. 截取完整的字符串
• 5. 从开始位置，每隔一个字符截取字符串
• 6. 从索引 1 开始，每隔一个取一个
• 7. 截取从 2 ~ 末尾 - 1 的字符串
• 8. 截取字符串末尾两个字符
• 9. 字符串的逆序（面试题）

答案

num_str = "0123456789"

# 1. 截取从 2 ~ 5 位置 的字符串
print(num_str[2:6])

# 2. 截取从 2 ~ `末尾` 的字符串
print(num_str[2:])

# 3. 截取从 `开始` ~ 5 位置 的字符串
print(num_str[:6])

# 4. 截取完整的字符串
print(num_str[:])

# 5. 从开始位置，每隔一个字符截取字符串
print(num_str[::2])

# 6. 从索引 1 开始，每隔一个取一个
print(num_str[1::2])

# 倒序切片
# -1 表示倒数第一个字符
print(num_str[-1])

# 7. 截取从 2 ~ `末尾 - 1` 的字符串
print(num_str[2:-1])

# 8. 截取字符串末尾两个字符
print(num_str[-2:])

# 9. 字符串的逆序（面试题）
print(num_str[::-1])

23/公共方法

24、Python 内置函数

Python 包含了以下内置函数：

函数	描述	备注
len(item)	计算容器中元素个数
del(item)	删除变量	del 有两种方式
max(item)	返回容器中元素最大值	如果是字典，只针对 key 比较
min(item)	返回容器中元素最小值	如果是字典，只针对 key 比较
cmp(item1, item2)	比较两个值，-1 小于/0 相等/1 大于	Python 3.x 取消了 cmp 函数

注意

• 字符串 比较符合以下规则： “0” < “A” < “a”

25、LINUX 上的 Shebang 符号(#!)

Shebang通常在Unix` 系统脚本的中 第一行开头 使用

指明 执行这个脚本文件 的 解释程序

26、局部变量和全局变量

27、函数的返回值为多个

函数的返回值为元组可返回多个值

 return (temp, wetness)

示：如果一个函数返回的是元组，括号可以省略

28、面试题 —— 交换两个数字

题目要求

1. 有两个整数变量 a = 6, b = 100

2. 不使用其他变量，交换两个变量的值

   解法 3—— Python 专有，利用元组

   a, b = b, a
   

29、缺省参数

1) 缺省参数的定义位置

必须保证 带有默认值的缺省参数 在参数列表末尾

2. 调用带有多个缺省参数的函数

在 调用函数时，如果有 多个缺省参数，需要指定参数名，这样解释器才能够知道参数的对应关系！

30、多值参数

• 参数名前增加 一个 * 可以接收 元组

• 参数名前增加 两个 * 可以接收 字典

  def demo(num, *args, **kwargs):
  
      print(num)
      print(args)
      print(kwargs)
  
  
  demo(1, 2, 3, 4, 5, name="小明", age=18, gender=True)
  

31、递归

提示：递归是一个 编程技巧，初次接触递归会感觉有些吃力！在处理 不确定的循环条件时，格外的有用，例如：遍历整个文件目录的结构

二、类与对象

1、dir 内置函数

01	__new__	方法	创建对象时，会被 自动 调用
02	__init__	方法	对象被初始化时，会被 自动 调用
03	__del__	方法	对象被从内存中销毁前，会被 自动 调用
04	__str__	方法	返回对象的描述信息，print 函数输出使用

2、定义类

• 在 Python 中要定义一个只包含方法的类，语法格式如下：

class 类名:

    def 方法1(self, 参数列表):
        pass
    
    def 方法2(self, 参数列表):
        pass

• 方法 的定义格式和之前学习过的函数 几乎一样

• 区别在于第一个参数必须是 self，大家暂时先记住，稍后介绍 self

3、创建对象

对象变量 = 类名()

4、第一个面向对象程序

class Cat:
    """这是一个猫类"""

    def eat(self):
        print("小猫爱吃鱼")

    def drink(self):
        print("小猫在喝水")

tom = Cat()
tom.drink()
tom.eat()

5、方法中的 self 参数

由 哪一个对象 调用的方法，方法内的 self 就是 哪一个对象的引用

• 在类封装的方法内部，self 就表示 当前调用方法的对象自己
• 调用方法时，程序员不需要传递 self 参数
• 在方法内部
  • 可以通过 self. 访问对象的属性
  • 也可以通过 self. 调用其他的对象方法
• 改造代码如下：

class Cat:

    def eat(self):
        print("%s 爱吃鱼" % self.name)

tom = Cat()
tom.name = "Tom"
tom.eat()

lazy_cat = Cat()
lazy_cat.name = "大懒猫"
lazy_cat.eat()

• 在 类的外部，通过 变量名. 访问对象的 属性和方法
• 在 类封装的方法中，通过 self. 访问对象的 属性和方法

6、初始化方法

class Cat:

    def __init__(self, name):
        print("初始化方法 %s" % name)
        self.name = name
    ...
    
tom = Cat("Tom")
...

lazy_cat = Cat("大懒猫")
...

7、删除对象

del 关键字可以删除一个对象

del tom

8、__str__ 方法

def str(self):
return “我是小猫：%s” % self.name

注意：__str__ 方法必须返回一个字符串

9、 身份运算符

身份运算符用于 比较 两个对象的 内存地址 是否一致 —— 是否是对同一个对象的引用

• 在 Python 中针对 None 比较时，建议使用 is 判断

运算符	描述	实例
is	is 是判断两个标识符是不是引用同一个对象	x is y，类似 id(x) == id(y)
is not	is not 是判断两个标识符是不是引用不同对象	x is not y，类似 id(a) != id(b)

10、私有属性和私有方法

• 在 定义属性或方法时，在 属性名或者方法名前 增加 两个下划线，定义的就是 私有 属性或方法

11、伪私有属性和私有方法

*提示：在日常开发中，不要使用这种方式，*访问对象的 私有属性 或 私有方法

处理方式**：在 名称 前面加上 _类名 => _类名__名称

# 私有属性，外部不能直接访问到
print(xiaofang._Women__age)

# 私有方法，外部不能直接调用
xiaofang._Women__secret()

12、 继承的语法

class 类名(父类名):

    pass

13、MRO —— 方法搜索顺序

MRO 是 method resolution order，主要用于 在多继承时判断 方法、属性 的调用 路径

print(C.mro)

14、is 与 == 区别：

is 用于判断 两个变量 引用对象是否为同一个
== 用于判断 引用变量的值 是否相等

15、方法的重写

在 子类中 定义了一个 和父类同名的方法并且实现

在需要的位置使用 super().父类方法 来调用父类方法的执行

调用父类方法的另外一种方式（知道）

父类名.方法(self)

这种方法 不推荐使用，因为一旦 父类发生变化，方法调用位置的 类名 同样需要修改

16、父类的 私有属性 和 私有方法

1. 子类对象 不能 在自己的方法内部，直接 访问 父类的 私有属性 或 私有方法
2. 子类对象 可以通过 父类 的 公有方法 间接 访问到 私有属性 或 私有方法

17、多态

• 在程序执行时，传入不同的 狗对象 实参，就会产生不同的执行效果

18、类属性和实例属性

class Tool(object):

    # 使用赋值语句，定义类属性，记录创建工具对象的总数
    count = 0

    def __init__(self, name):
        self.name = name

        # 针对类属性做一个计数+1
        Tool.count += 1

因此，要访问类属性有两种方式：

1. 类名.类属性
2. 对象.类属性 （不推荐）

• 如果使用 对象.类属性 = 值 赋值语句，只会 给对象添加一个属性，而不会影响到 类属性的值

19、类方法

• 在 类方法 内部可以直接访问 类属性 或者调用其他的 类方法

语法如下

@classmethod
def 类方法名(cls):
    pass

• 类方法需要用 修饰器 @classmethod 来标识，告诉解释器这是一个类方法

在类方法内部，可以直接使用 cls 访问 类属性 或者 调用类方法

20、静态方法

语法如下

@staticmethod
def 静态方法名():
    pass

• 静态方法 需要用 修饰器 @staticmethod 来标识，告诉解释器这是一个静态方法
• 通过 类名. 调用 静态方法

21、单例设计模式的应用场景

• 音乐播放 对象
• 回收站 对象
• 打印机 对象

22、单例实现

1. 重写 __new__ 方法
2. 只执行一次初始化工作，重写 __init__ 方法

23、捕获异常

try:
    # 尝试执行的代码
    pass
except 错误类型1:
    # 针对错误类型1，对应的代码处理
    pass
except (错误类型2, 错误类型3):
    # 针对错误类型2 和 3，对应的代码处理
    pass
except Exception as result:
    print("未知错误 %s" % result)

24、抛出 raise 异常

1. 创建 一个 Exception 的 对象
2. 使用 raise 关键字 抛出 异常对象

 # 1> 创建异常对象 - 使用异常的错误信息字符串作为参数
    ex = Exception("密码长度不够")

    # 2> 抛出异常对象
    raise ex

25、导入模块

import 模块名1

• 通过 模块名. 使用 模块提供的工具 —— 全局变量、函数、类

使用 as 指定模块的别名

如果模块的名字太长*，可以使用* as 指定模块的名称，以方便在代码中的使用

import 模块名1 as 模块别名

from…import 导入部分

# 从 模块 导入 某一个工具
from 模块名1 import 工具名

如果 两个模块*，存在* 同名的函数*，那么* 后导入模块的函数*，会* 覆盖掉先导入的函数

这种方式不推荐使用，因为函数重名并没有任何的提示，出现问题不好排查

26、__name__ 属性

• 如果 是被其他文件导入的，__name__ 就是 模块名
• 如果 是当前执行的程序 __name__ 是 main

在导入文件时，文件中 所有没有任何缩进的代码 都会被执行一遍！

在很多 Python 文件中都会看到以下格式的代码：

# 导入模块
# 定义全局变量
# 定义类
# 定义函数

# 在代码的最下方
def main():
    # ...
    pass

# 根据 __name__ 判断是否执行下方代码
if __name__ == "__main__":
    main()

27、包

概念

• 包 是一个 包含多个模块 的 特殊目录
• 目录下有一个 特殊的文件 __init__.py
• 包名的 命名方式 和变量名一致，小写字母 + _

好处

• 使用 import 包名 可以一次性导入 包 中 所有的模块

• 要在外界使用 包 中的模块，需要在 __init__.py 中指定 对外界提供的模块列表

# 从 当前目录 导入 模块列表
from . import send_message
from . import receive_message

28、pip 安装第三方模块

安装和卸载命令如下：

# 将模块安装到 Python 2.x 环境
$ sudo pip install pygame
$ sudo pip uninstall pygame

# 将模块安装到 Python 3.x 环境
$ sudo pip3 install pygame
$ sudo pip3 uninstall pygame

29、文件的基本操作

• 注意：read 方法执行后，会把 文件指针 移动到 文件的末尾

# 1. 打开 - 文件名需要注意大小写
file = open("README")

# 2. 读取
text = file.read()
print(text)

# 3. 关闭
file.close()

提示

• 在开发中，通常会先编写 打开 和 关闭 的代码，再编写中间针对文件的 读/写 操作！

频繁的移动文件指针，会影响文件的读写效率，开发中更多的时候会以 只读、只写 的方式来操作文件

语法如下：

f = open("文件名", "访问方式")

访问方式	说明
r	以只读方式打开文件。文件的指针将会放在文件的开头，这是默认模式。如果文件不存在，抛出异常
w	以只写方式打开文件。如果文件存在会被覆盖。如果文件不存在，创建新文件
a	以追加方式打开文件。如果该文件已存在，文件指针将会放在文件的结尾。如果文件不存在，创建新文件进行写入
r+	以读写方式打开文件。文件的指针将会放在文件的开头。如果文件不存在，抛出异常
w+	以读写方式打开文件。如果文件存在会被覆盖。如果文件不存在，创建新文件
a+	以读写方式打开文件。如果该文件已存在，文件指针将会放在文件的结尾。如果文件不存在，创建新文件进行写入

30、按行读取文件内容

text = file.readline()

if not text:
break

31、文件/目录的常用管理操作

文件操作

序号	方法名	说明	示例
01	rename	重命名文件	os.rename(源文件名, 目标文件名)
02	remove	删除文件	os.remove(文件名)

目录操作

序号	方法名	说明	示例
01	listdir	目录列表	os.listdir(目录名)
02	mkdir	创建目录	os.mkdir(目录名)
03	rmdir	删除目录	os.rmdir(目录名)
04	getcwd	获取当前目录	os.getcwd()
05	chdir	修改工作目录	os.chdir(目标目录)
06	path.isdir	判断是否是文件	os.path.isdir(文件路径)

提示：文件或者目录操作都支持 相对路径 和 绝对路径

32、eval 函数

eval() 函数十分强大 —— 将字符串 当成 有效的表达式 来求值 并 返回计算结果

三、飞机大战

练习

1、04_面向对象封装案例

2、05_面向对象封装案例 II

3、方法综合案例

需求

1. 设计一个 Game 类

2. 属性：

   • 定义一个 类属性 top_score 记录游戏的 历史最高分
   • 定义一个 实例属性 player_name 记录 当前游戏的玩家姓名

3. 方法：

   • 静态方法 show_help 显示游戏帮助信息
   • 类方法 show_top_score 显示历史最高分
   • 实例方法 start_game 开始当前玩家的游戏

   主程序步骤

   • 1. 查看帮助信息
   • 2. 查看历史最高分
   • 3. 创建游戏对象，开始游戏

问题

1、在 Python给对象设置属性****但是不推荐使用

• 因为：对象属性的封装应该封装在类的内部，

• 只需要在 类的外部的代码 中直接通过 . 设置一个属性即可

  为什么？？

答：应该在初始化方法了赋值

2、为什么要手动删除一个对象