文章目录

• 一、变量与运算符
• • 1. 变量（标识符）
  • 2. 变量赋值
  • 3. 运算符
  • • 逻辑运算符
    • 位运算符
    • 成员运算符
    • 身份运算符
• 二、控制与循环
• • 1. 条件控制
  • 2. 循环
  • 3. 循环控制语句
• 三、函数
• • 1. 函数的参数
  • 2. 位置
  • 3. 不定长参数
  • 4. 函数返回值
• 四、数据结构
• • 1. 数字类型
  • • 使用：
  • 2. 字符串
  • • 转义字符：
    • 格式化
    • 常用函数方法
  • 3. 列表
  • 4. 元组
  • 5. 字典
  • 6. 集合
• 五、文件操作
• • 1. 读写文件
  • 2. 文件对象
• 六、模块化
• 七、错误与异常
• • 1.异常处理
  • 2. 抛出异常
• 八、面向对象
• • 1.类
  • • 1.1 属性引用
    • 1.2 实例化，
  • 2.继承
  • 3.多继承
• 九、Python高级特性
• • 1.迭代器与生成器
  • • 1.1 迭代器
    • 1.2 类作为迭代器
    • 1.3 生成器
    • 1.4 生成器表达式
  • 2. 装饰器
  • • 2.1 装饰器函数
    • 2.2 类装饰器
  • 3. 匿名函数
  • ４. 元类
  • ５.多线程
  • ６．全局解释器锁ＧＩＬ
  • ７　用户自定义异常

一、变量与运算符

1. 变量（标识符）

变量命名：

1. 数字、字母、_ ，且数字不在最前
2. apple_price, applePrice

2. 变量赋值

i = j = k = 1
type(i)
print(i,j,k,sep=',')

3. 运算符

// 向下取整
% 取余

逻辑运算符

and：
a and b a为False，返回False；a为True，返回b。
or
a or b a为True，返回True；a为False，返回b。
not

位运算符

>> 右移一位
<< 左移一位

成员运算符

in
not in
字符串、列表、元组

身份运算符

is
is not
比较存储单元是否相同

二、控制与循环

1. 条件控制

if
elif
else

2. 循环

while ：pass# 占位，暂时没有思路的代码块
else：

for i in range()

3. 循环控制语句

1. break 跳出当前循环体
2. continue 跳过本轮循环的剩余语句，继续进行下一轮循环

三、函数

1. 函数的参数

形参（定义函数时给定的参数）
实参（调用函数时提供的参数）

2. 位置

位置参数需要出现在默认参数之前

def print_f(name='Alice',age):print('name:',name)print('age:',age)

3. 不定长参数

*args：元组形式导入
**args：字典形式导入

def print_f(name,*args):print(args)

def print_f(name,**args):print(args)

4. 函数返回值

多个return x,y

四、数据结构

1. 数字类型

1. int
2. float(计算结果包含的小数位数可能不确定)
3. complex

使用：

1. abs(-10) 绝对值 10
2. math.ceil(4.1) 5
3. math.floor(4.1) 4
4. power(3,2) 9
5. sqrt(9) 3

2. 字符串

不可变

转义字符：

hello = 'hello!\n\"Python\"'
print(hello)hello!
"Python"

格式化

time = '今天是%d年%s星期%d'%(2020,'8月27日',4)time = '今天是{}年{}星期{}'.format(2020,'8月27日','五')今天是2020年8月27日星期4

• 小数表示方式
  %.2f
  {:.2f}

# 小数格式化输出
a = 1.2222
print('输出a的两位小数形式{:.2f}'.format(a))
print('输出a的两位小数形式%.2f'%(a))输出a的两位小数形式1.22
输出a的两位小数形式1.22

常用函数方法

判断是否以特定的字符开头/结尾
>>> hello = 'hello!\n\"Python\"'
>>> hello.startswith('h')
True
>>> hello.endswith('h')
False

>>> a = 'python'
>>> a.replace('p','')
>并不会改变原来a的值，若使用需要赋值

replace(old,new,[替换次数])

>>> a.upper()
'PYTHON'
>>> a.lower()
'python'

>>> hi = '   hi   '
>>> hi.strip()
'hi'

3. 列表

1. 列表运算
   list_a + list_b
   list_a * 3

2. 排序

# sorted() 不会改变原来的数组
>>> l1 = [3,4,1,6]
>>> sorted(l1)
[1, 3, 4, 6]
>>> l1
[3, 4, 1, 6]# l.sort() 会改变原来的数组
>>> l1.sort()
>>> l1
[1, 3, 4, 6]# 从大到小排序
>>> l1.sort(reverse=True)
>>> l1
[6, 4, 3, 1]

3. 增删操作

l.append()
l.insert()
l.pop()
del l[0]

pop删除指定索引位置

l.pop(0)
del l[0]

4. 元组

不可增删改，对多个返回值进行封装;
可替换或重建
t = tuple()

>>> t = (1,2)
>>> t1 = (3,4,5)
>>> t = t1
>>> t
(3, 4, 5)
>>> t = (4,5)
>>> t
(4, 5)

交换两个数的值

>>> i = 1
>>> j = 2
>>> i,j = j,i
>>> i,j
(2, 1)

5. 字典

>>> dt = {i:i**2 for i in range(5)}
>>> dt
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

6. 集合

{}
.add()
.remove()
& 交集
| 并集

五、文件操作

1. 读写文件

• open(file,mode)
• mode: ‘r’,‘w’（覆盖或空文件写入）,‘a’(追加模式，末尾写入不覆盖原有内容)
• newline:区分换行

input = open('test.txt')input.close()

• with open 自动释放访问的文件对象，不需要手动释放
• 预定义清理行为

with open('file.txt','r') as f:print(f.readline())

• 写文件
  with open(‘file.txt’,‘a’) as f:
  line = f.write(‘python’)

在这里插入代码片

2. 文件对象

• file.next()
• file.read([size])：读取指定字节数
• file.readline()：整行，包括换行符‘\n’
• file.write(str)

• 二进制文件

open('1.text','rb')

六、模块化

增强代码内聚性，可重用性

从模块中导入部分
from fibo import fibo
from fibo import *
import fibo

• __name__
• 属性
  判断是独立运行还是被导入

if __name__ == "__main__":print('此为自己所用')
else:print('此为被导入运行')

七、错误与异常

• 语法错误（syntax error）
• 异常（exceptions）
  ZeroDivisionError
  NameError
  TypeError
  …

1.异常处理

使用else语句比直接在try后面写代码好，可以准确捕获异常，不截获本来不属于他们保护的代码抛出的异常。

try:f = open(arg,'r')
except IOError:print('cannot open',arg)
else:print(arg,'has',len(f.readline()),'lines')f.close()

2. 抛出异常

raise [异常名]（‘hi’）

def input_password():# 提示用户输入密码pwd = input("请输入密码：")# 判读密码长度大于等于8，返回用户输入的密码if len(pwd) >= 8:return pwd# 如果小于8，则抛出异常print("主动抛出异常")# 创建异常对象ex = Exception("密码长度不够")# 抛出异常对象raise ex
# 提示用户输入密码
try:print(input_password())
except Exception as result:print(result)
finally:print('这个句子总会被执行')

• finally 用于释放外部资源（文件，网络资源等）

八、面向对象

1.类

1.1 属性引用

class MyClass(object):"""docstring for MyClass"""i = 123def __init__(self, arg):super(MyClass, self).__init__()self.arg = argif __name__ == '__main__':print(MyClass.i)print(MyClass.__init__)print(MyClass.__doc__)# 返回整数
123
# 返回方法
<function MyClass.__init__ at 0x03871418>
# 返回文档字符串
docstring for MyClass

1.2 实例化，

创建的函数自动带有init内的参数

x = MyClass()

__init__定义初始状态

2.继承

Inheritance

• isinstance（a, int）检查实例类型，是否是实例化
• issubclass(float, int) 检查类继承

3.多继承

DerivedClassName(Base1，Base2，Base3) 深度优先搜索
super（）动态地改变解析过程

九、Python高级特性

1.迭代器与生成器

1.1 迭代器

迭代器：记录集合遍历位置的对象，两个基本的方法

• iter()
• next()

list = [1,2,3,4]
it = iter(list)
print(next(it))
>> 1
print(next(it))
>> 2

1.2 类作为迭代器

需要创建类的__iter__和__next__方法

# 实现初始值1，逐步递增1
class MyClass(object):"""docstring for MyClass"""def __iter__(self):self.a = 1return selfdef __next__(self):x = self.a self.a += 1return x
myclass = MyClass()
myiter = iter(myclass)print(next(myiter))
print(next(myiter))
print(next(myiter))>>
1
2
3

• 有限次数时，触发

# 实现初始值1，逐步递增1，运行10次
class MyClass(object):"""docstring for MyClass"""def __iter__(self):self.a = 1return selfdef __next__(self):x = self.a if x <= 10:self.a += 1return xelse:raise StopIterationmyclass = MyClass()
myiter = iter(myclass)for i in myiter:print(i)>>1 2 3 4 5 6 7 8 9 10 

1.3 生成器

生成器：使用了yield的函数，返回迭代器
每次遇到遇到yield会暂停并保存所有信息，在遇到next() 后继续运行

import sys
def fibo(n):a,b,counter = 0,1,0for x in range(n):yield aa,b = b,a+bf = fibo(10)
while True:try:print(next(f),end=' ')except StopIteration:sys.exit()
> 0 1 1 2 3 5 8 13 21 34

1.4 生成器表达式

import sys
N = (i**2 for i in range(5))
N1 = [i**2 for i in range(5)]
N2 = {i**2 for i in range(5)}
print(N)
print(N1)
print(N2)while True:try:print(next(N),end=' ')except StopIteration:sys.exit()
>>
<generator object <genexpr> at 0x038E1C30> # 一个生成器
[0, 1, 4, 9, 16]
{0, 1, 4, 9, 16}
0 1 4 9 16 # 输出需要异常检测

2. 装饰器

2.1 装饰器函数

给其他函数添加特定的修饰方法，来进行一些额外的处理，如日志记录、时间统计

import time
from functools import wraps
def timethis(func):@wraps(func)def wrapper(*args,**kwargs):start = time.time()result = func(*args,**kwargs)end = time.time()print(func.__name__,end-start)return resultreturn wrapper@timethis
def fibo(n):a,b = 0,1for x in range(n):a,b = b,a+breturn a
fibo(10000)fibo 0.026985645294189453
[Finished in 0.3s]

前面计时函数写好，使用时只需要在func前面加上 @timethis 就好了

2.2 类装饰器

3. 匿名函数

lambda：只是一个表达式，只能使用自己命名空间内的参数
匿名：不再使用def语句来定义函数

s = lambda a,b:a+b
print(s)
print('相加之后的值为:',s(1,2))<function <lambda> at 0x00D41418>
相加之后的值为: 3

４. 元类

５.多线程

ｔｈｒｅａｄ

６．全局解释器锁ＧＩＬ

解释器的Ｃ语言实现部分不是线程安全的，确保任何时候都只有一个ｐｙｔｈｏｎ线程执行。
＊问题：
ｐｙｔｈｏｎ多线程不能利用多核ｃｐｕ优势，影响计算型程序
解决方法：
１.　完全工作于ｐｙｔｈｏｎ环境，使用ｍｕｌｔｉｐｒｏｃｅｓｓｉｎｇ模块创建进程池，像协同处理器一样使用。

２.　ｃ扩展编程

７　用户自定义异常

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！