python笔记_python语法a==

pythinpython笔记

一、基础语法

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

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

2、多行注释：

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

3、算数运算符

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

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

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

4、type(name)

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

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

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

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

6、变量的输入

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

7、类型转换函数

8、变量的格式化输出

• 语法格式如下：

  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)
  1
  2

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

10、if语句

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

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

11、逻辑运算

and / or/ not

12、随机数的处理

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

import random
1

• 导入模块后，可以直接在 模块名称 后面敲一个 . 然后按 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)  # 该语句是错误的，下限必须小于上限
1
2
3

13、while` 循环

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

print("循环结束后的 i = %d" % i)
1
2
3
4
5
6

14/转义字符

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

15、函数封装定义

def

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

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

16、导入模块

import

import hm_10_分隔线模块

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

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)
1
2
3
4

20、元组

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

元组用 () 定义

info_tuple = (“zhangsan”, 18, 1.75)

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

元组和列表之间的转换

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

list(元组) 
1

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

tuple(列表)
1

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   
1
2
3
4
5

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

1) 判断类型 - 9

2) 查找和替换 - 7

3) 大小写转换 - 5

4) 文本对齐 - 3

5) 去除空白字符 - 3

6) 拆分和连接 - 5

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

23/公共方法

24、Python 内置函数

Python 包含了以下内置函数：

注意

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

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

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

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

26、局部变量和全局变量

27、函数的返回值为多个

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

 return (temp, wetness)
1

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

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

题目要求

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

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

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

   a, b = b, a
   1

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)
  1
  2
  3
  4
  5
  6
  7
  8

31、递归

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

二、类与对象

1、dir 内置函数

2、定义类

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

class 类名:

    def 方法1(self, 参数列表):
        pass
    
    def 方法2(self, 参数列表):
        pass
1
2
3
4
5
6
7

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

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

3、创建对象

对象变量 = 类名()

4、第一个面向对象程序

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

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

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

tom = Cat()
tom.drink()
tom.eat()
1
2
3
4
5
6
7
8
9
10
11
12

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()
1
2
3
4
5
6
7
8
9
10
11
12

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

6、初始化方法

class Cat:

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

lazy_cat = Cat("大懒猫")
...
1
2
3
4
5
6
7
8
9
10
11
12

7、删除对象

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

del tom

8、__str__ 方法

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

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

9、 身份运算符

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

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

10、私有属性和私有方法

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

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

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

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

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

# 私有方法，外部不能直接调用
xiaofang._Women__secret()
1
2
3
4
5

12、 继承的语法

class 类名(父类名):

    pass
1
2
3

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
3
4
5
6
7
8
9
10
11

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

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

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

19、类方法

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

语法如下

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

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

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

20、静态方法

语法如下

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

• 静态方法 需要用 修饰器 @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)
1
2
3
4
5
6
7
8
9
10
11

24、抛出 raise 异常

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

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

    # 2> 抛出异常对象
    raise ex
1
2
3
4
5

25、导入模块

import 模块名1
1

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

使用 as 指定模块的别名

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

import 模块名1 as 模块别名
1

from…import 导入部分

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

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

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

26、__name__ 属性

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

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

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

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

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

# 根据 __name__ 判断是否执行下方代码
if __name__ == "__main__":
    main()
1
2
3
4
5
6
7
8
9
10
11
12
13

27、包

概念

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

好处

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

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

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

28、pip 安装第三方模块

安装和卸载命令如下：

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

# 将模块安装到 Python 3.x 环境
$ sudo pip3 install pygame
$ sudo pip3 uninstall pygame
1
2
3
4
5
6
7

29、文件的基本操作

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

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

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

# 3. 关闭
file.close()
1
2
3
4
5
6
7
8
9

提示

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

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

语法如下：

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

30、按行读取文件内容

text = file.readline()

if not text:
break

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

文件操作

目录操作

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

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、为什么要手动删除一个对象