Python基础

1.数据类型
数值类型

• 整数(int)
  Python中的整数包括正整数、0 和负整数。可以使用多种进制来表示整数：
  (1) 十进制形式
  (2) 二进制形式书写时以0b或0B开头
  (3) 八进制形式以0o或0O开头
  (4) 十六进制形式书写时以0x或0X开头。
• 浮点数(float)
  Python 中的小数有两种书写形式：
  (1) 十进制形式
  这种就是我们平时看到的小数形式，例如 34.6、346.0、0.346。
  书写小数时必须包含一个小数点，否则会被 Python 当作整数处理。
  (2) 指数形式aEn 或 aen：a 为尾数部分，是一个十进制数；n 为指数部分，是一个十进制整数；E或e是固定的字符，用于分割尾数部分和指数部分。整个表达式等价于 a×10n。
  指数形式的小数举例：
  2.1E5 = 2.1×105，其中 2.1 是尾数，5 是指数。
  3.7E-2 = 3.7×10-2，其中 3.7 是尾数，-2 是指数。
  0.5E7 = 0.5×107，其中 0.5 是尾数，7 是指数。
  注意，只要写成指数形式就是小数，即使它的最终值看起来像一个整数。例如 14E3 等价于 14000，但 14E3 是一个小数。
• 复数（Complex）
  是Python的内置类型，直接书写即可。换句话说，Python 语言本身就支持复数，而不依赖于标准库或者第三方库。复数由实部（real）和虚部（imag）构成，在 Python 中，复数的虚部以j或者J作为后缀，具体格式为：a + bj
• 字符串（str）
  若干个字符的集合就是一个字符串。Python 中的字符串必须由双引号" "或者单引号’ ‘包围，具体格式为：“字符串内容”、‘字符串内容’。字符串内容可以包含字母、标点、特殊符号、中文等全世界的所有文字。
  (1).处理字符串中的引号：
  1).对引号进行转义，在引号前面添加反斜杠\就可以对引号进行转义，让 Python 把它作为普通文本对待。
  2).使用不同的引号包围字符串
  如果字符串内容中出现了单引号，那么我们可以使用双引号包围字符串，反之亦然。
  3).如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r’‘表示’‘内部的字符串默认不转义
  (2).字符串是以Unicode编码的，支持多语言。对于单个字符的编码，Python提供了 ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符。
  (3).str和bytes
  由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。
  Python对bytes类型的数据用带b前缀的单引号或双引号表示：x = b'ABC'
  要注意区分’ABC’和b’ABC’，前者是str，后者虽然内容显示得和前者一样，但bytes的每个字符都只占用一个字节。
  以Unicode表示的str通过 encode() 方法可以编码为指定的bytes，例如：

>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
>>> '中文'.encode('ascii')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

纯英文的str可以用ASCII编码为bytes，内容是一样的，含有中文的str可以用UTF-8编码为bytes。含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错。在bytes中，无法显示为ASCII字符的字节，用\x##显示。
反过来，如果我们从网络或磁盘上读取字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用 decode() 方法。如果bytes中只有一小部分无效的字节，可以传入errors='ignore’忽略错误的字节：

>>> b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')
'中'

要计算str包含多少个字符，可以用 len() 函数：

• 数据分割符
  为了提高数字的的可读性，Python 3.x 允许使用下划线_作为数字（包括整数和小数）的分隔符。通常每隔三个数字添加一个下划线，类似于英文数字中的逗号。下划线不会影响数字本身的值。
• 布尔值(bool)
  Python 提供了 bool 类型来表示真（对）或假（错），True 和 False 是 Python 中的关键字，当作为 Python 代码输入时，要注意字母的大小写。
• 列表(list)
  [数据1, 数据2, 数据3, 数据4…]
  常用操作：
  index()：返回指定数据所在位置的下标
  count()：统计指定数据在当前列表中出现的次数
  len()：访问列表⻓度，即列表中数据的个数
  in：判断指定数据在某个列表序列，如果在返回True，否则返回False
  not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False
  append()：列表结尾追加数据，如果append()追加的数据是⼀个序列，则追加整个序列到列表
  extend()：列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表。
  insert()：指定位置新增数据
  del ⽬标
  pop()：删除指定下标的数据(默认为最后⼀个)，并返回该数据
  remove()：移除列表中某个数据的第⼀个匹配项
  clear()：清空列表
  reverse()：逆置
  sort()：排序
  语法：列表序列.sort( key=None, reverse=False)
  reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）
  copy()：复制函数
• 元组(tuple)
  ⼀个元组可以存储多个数据，元组内的数据是不能修改的，修改会报错，但是如果元组⾥⾯有列表，修改列表⾥⾯的数据则是⽀持的
  元组特点：定义元组使⽤⼩括号，且逗号隔开各个数据，数据可以是不同的数据类型
  如果定义的元组只有⼀个数据，那么这个数据后⾯也好添加逗号，否则数据类型为唯⼀的这个数据的数据类型
  index()：查找某个数据，如果数据存在返回对应的下标，否则报错
  count()：统计某个数据在当前元组出现的次数
  len()：统计元组中数据的个数
• 集合(set)
  创建集合使⽤ {} 或 set() ， 但是如果要创建空集合只能使⽤ set() ，因为 {} ⽤来创建空字典
  特点： 集合可以去掉重复数据；集合数据是⽆序的，故不⽀持下标
  add()
  update(), 追加的数据是序列
  remove()，删除集合中的指定数据，如果数据不存在则报错
  discard()，删除集合中的指定数据，如果数据不存在也不会报错
  pop()，随机删除集合中的某个数据，并返回这个数据
  in：判断数据在集合序列
  not in：判断数据不在集合序列
• 字典(dict)
  特点：符号为⼤括号；数据为键值对形式出现；各个键值对之间⽤逗号隔开
  写法：字典序列[key] = 值
  如果key存在则修改这个key对应的值；如果key不存在则新增此键值对
  del() / del：删除字典或删除字典中指定键值对
  clear()：清空字典

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
del dict1['gender']
# 结果：{'name': 'Tom', 'age': 20}
print(dict1)

get()
语法： 字典序列.get(key, 默认值)
如果当前查找的key不存在则返回第⼆个参数(默认值)，如果省略第⼆个参数，则返回None
keys()：返回所有key值
values()
items()
key值查找:

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1['name']) # Tom
print(dict1['id']) # 报错

• 空值
  空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

2.变量

• 变量在Python内部是有类型的，比如 int、float 等，但是我们在编程时无需关注变量类型，所有的变量都无需提前声明，赋值后就能使用。另外，可以将不同类型的数据赋值给同一个变量，所以变量的类型是可以改变的

3.字符编码

• ASCII编码是1个字节，Unicode编码通常是2个字节，UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母是1个字节，汉字通常是3个字节，只有很生僻的字符会被编码成4-6个字节。
• 现代计算机系统通用的字符编码工作方式：在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件。
• Python 3的字符串使用Unicode编码，直接支持多语言，当str和bytes互相转换时，需要指定编码。最常用的编码是UTF-8
• 由于Python源代码也是一个文本文件，所以，当源代码中包含中文的时候，在保存源代码时，就需要指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上：# -*- coding: utf-8 -*-否则，在源代码中写的中文输出可能会有乱码。

4.格式化

• 格式化符号
  %s：格式化输出字符串
  %d：格式化输出整数
  %f：格式化输出浮点数
• f-字符串
  f’{表达式}’
• 转义字符
  \n：换⾏
  \t：制表符

print('我的名字是%s，明年%d岁了' % (name, age + 1))
print(f'我的名字是{name}, 明年{age + 1}岁了')

• print结束符
  print(‘输出的内容’, end="\n")
  print(‘内容’, end="")

5.注释

• 单⾏： # 注释内容 ，快捷键ctrl+/
• 多⾏： “”" 注释内容 “”" 或 ‘’’ 注释内容 ‘’’

6.输入

• input()函数：
  input() 是 Python 的内置函数，用于从控制台读取用户输入的内容。input() 函数总是以字符串的形式来处理用户输入的内容，所以用户输入的内容可以包含任何字符。input() 函数的用法为：str = input(msg)

a = input("Enter a number: ")
b = input("Enter another number: ")

7.数据类型转换

• 数据类型转换函数
  int(string) 将字符串转换成 int 类型；
  float(string) 将字符串转换成 float 类型；
  bool(string) 将字符串转换成 bool 类型。
  eval(str) 将字符串中的数据转换成Python表达式原本类
  tuple(s) 将序列 s 转换为⼀个元组
  list(s) 将序列 s 转换为⼀个列表
  set(s) 将序列s转换成集合
  8.条件语句
  多重判断

if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

嵌套语句

if <条件判断1>:
  <执行1>
  if <条件判断2>:
    <执行2>

三目运算式

条件成⽴执⾏的表达式 if 条件 else 条件不成⽴执⾏的表达

9.循环
for循环

for x in n(可迭代对象，或range())

while循环

while <条件> :
   <执行1>
   <执行2>
   <执行3>

while嵌套循环

while <条件> :
  <执行1>
  <执行2>
  while<条件>
     <执行3>
     <执行4>

break 退出整个循环
continue 跳过本次循环
where和for都可以搭配else使用：
else下⽅缩进的代码含义：当循环正常结束后执⾏的代码
break终⽌循环不会执⾏else下⽅缩进的代码
continue退出循环的⽅式执⾏else下⽅缩进的代码

10.切片
切⽚是指对操作的对象截取其中⼀部分的操作。字符串、列表、元组都⽀持切⽚操作。
语法

序列[开始位置下标:结束位置下标:步⻓]

注意

1. 不包含结束位置下标对应的数据， 正负整数均可；
2. 步⻓是选取间隔，正负整数均可，默认步⻓为1。

常⽤操作⽅法
字符串的常用操作方法有查找，修改和判断三大类
查找：

• find()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则返回-1
• index()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则报异常
• rfind()： 和find()功能相同，但查找⽅向为右侧开始。
• rindex()：和index()功能相同，但查找⽅向为右侧开始。
• count()：返回某个⼦串在字符串中出现的次数

mystr = "hello world and item and items and Python"
print(mystr.index('and')) # 12
print(mystr.index('and', 15, 30)) # 23
print(mystr.index('ands')) # 报错
print(mystr.find('ands')) # -1
print(mystr.count('and')) # 3

修改:

• replace()：替换
  语法:字符串序列.replace(旧⼦串, 新⼦串, 替换次数)

mystr = "hello world and itcast and itheima and Python"
# 结果：hello world he itcast he itheima he Python
print(mystr.replace('and', 'he'))
# 结果：hello world he itcast he itheima he Python
print(mystr.replace('and', 'he', 10))
# 结果：hello world and itcast and itheima and Python
print(mystr)
#字符串类型的数据修改的时候不能改变原有字符串，不可变类型

• split()：按照指定字符分割字符串
  语法:字符串序列.split(分割字符, num)
  num表示分割字符出现的次数，即将来返回数据个数为num+1个

# 结果：['hello world ', ' itcast ', ' itheima ', ' Python']
print(mystr.split('and'))
# 结果：['hello world ', ' itcast ', ' itheima and Python']
print(mystr.split('and', 2)

• join()：⽤⼀个字符或⼦串合并字符串，即是将多个字符串合并为⼀个新的字符串
  语法:字符或⼦串.join(多字符串组成的序列)

ist1 = ['chuan', 'z', 'b', 'k']
# 结果：chuan_z_b_k
print('_'.join(list1))

• capitalize()：将字符串第⼀个字符转换成⼤写。
• title()：将字符串每个单词⾸字⺟转换成⼤写。
• lower()：将字符串中⼤写转⼩写
• upper()：将字符串中⼩写转⼤写
• lstrip()：删除字符串左侧空⽩字符
• rstrip()：删除字符串右侧空⽩字符
• strip()：删除字符串两侧空⽩字符
• ljust()：返回⼀个原字符串左对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串
  语法:字符串序列.ljust(⻓度, 填充字符)
• rjust()：返回⼀个原字符串右对⻬
• center()：返回⼀个原字符串居中对⻬

判断:

• startswith()：检查字符串是否是以指定⼦串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
  语法:字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标)
• endswith()：检查字符串是否是以指定⼦串结尾
• isalpha()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟则返回 True, 否则返回 False
• sdigit()：如果字符串只包含数字则返回 True 否则返回 False
• isalnum()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟或数字则返 回 True,否则返回False
• isspace()：如果字符串中只包含空⽩，则返回 True，否则返回 False

11.公共方法

函数	描述
len()	计算容器中元素个数
del 或 del()	删除
max()	返回容器中元素最⼤值
min()	返回容器中元素最⼩值
range(start,end, step)	⽣成从start到end的数字，步⻓为 step，供for循环使⽤
enumerate()	函数⽤于将⼀个可遍历的数据对象(如列表、元组或字符串)组合为⼀个索引序列，同时列出数据和数据下标，⼀般⽤在 for 循环当中

enumerate()
语法：enumerate(可遍历对象, start=0)
注意：start参数⽤来设置遍历数据的下标的起始值，默认为0。

list1 = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(list1):
print(i)
for index, char in enumerate(list1, start=1):
print(f'下标是{index}, 对应的字符是{char}')

12. 推导式
推导式的作⽤：简化代码
推导式写法

# 列表推导式
[xx for xx in range()]
# 字典推导式
{xx1: xx2 for ... in ...}
# 集合推导式
{xx for xx in ...}

13.函数
函数的作⽤：封装代码，⾼效的代码重⽤
函数使⽤步骤
定义函数

def 函数名():
 代码1
 代码2

调⽤函数

函数名()

函数的说明⽂档
作⽤：保存函数解释说明的信息

def 函数名():
 """ 函数说明⽂档 """

变量作⽤域
全局：函数体内外都能⽣效
局部：当前函数体内部⽣效
函数多返回值写法

return 表达式1, 表达式2...

函数的参数

• 位置参数
  形参和实参的个数和书写顺序必须⼀致
• 关键字参数
  写法： key=value
  特点：形参和实参的书写顺序可以不⼀致；关键字参数必须书写在位置参数的后⾯
• 缺省参数
  缺省参数就是默认参数
  写法： key=vlaue
• 不定⻓位置参数
  收集所有位置参数，返回⼀个元组,传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为⼀个元组(tuple)，args是元组类型，这就是包裹位置传递。

def user_info(*args):
  print(args)
# ('TOM',)
user_info('TOM')
# ('TOM', 18)
user_info('TOM', 18)

• 不定⻓关键字参数
  收集所有关键字参数，返回⼀个字典

def user_info(**kwargs):
 print(kwargs)
# {'name': 'TOM', 'age': 18, 'id': 110}
user_info(name='TOM', age=18, id=110)

⽆论是包裹位置传递还是包裹关键字传递，都是⼀个组包的过程
拆包：字典

dict1 = {'name': 'TOM', 'age': 18}
a, b = dict1
# 对字典进⾏拆包，取出来的是字典的key
print(a) # name
print(b) # age
print(dict1[a]) # TOM
print(dict1[b]) # 18

引⽤：Python中，数据的传递都是通过引⽤
我们可以⽤ id() 来判断两个变量是否为同⼀个值的引⽤。 我们可以将id值理解为那块内存的地址标识
14.递归
递归的特点：函数内部⾃⼰调⽤⾃⼰；必须有出⼝
15.lambda 表达式
lambda语法：

 lambda 参数列表 ： 表达式

lambda表达式的参数可有可⽆，函数的参数在lambda表达式中完全适⽤。
lambda函数能接收任何数量的参数但只能返回⼀个表达式的值
lambda的参数形式

• ⽆参数

print((lambda: 100)())

• ⼀个参数

 print((lambda a: a)('hello world'))

• 默认参数

 print((lambda a, b, c=100: a + b + c)(10, 20))

• 可变参数：**args

print((lambda *args: args)(10, 20, 30))

这⾥的可变参数传⼊到lambda之后，返回值为元组

• 可变参数：**kwargs

print((lambda **kwargs: kwargs)(name='python', age=20))

• ⾼阶函数
  把函数作为参数传⼊，这样的函数称为⾼阶函数，⾼阶函数是函数式编程的体现

def sum_num(a, b, f):
 return f(a) + f(b)
result = sum_num(-1, 2, abs)
print(result) # 3

• 内置⾼阶函数
  map()：map(func, lst)，将传⼊的函数变量func作⽤到lst变量的每个元素中，并将结果组成新的列表(Python2)/迭代器(Python3)返回

list1 = [1, 2, 3, 4, 5]
def func(x):
 return x ** 2
result = map(func, list1)
print(result) # <map object at 0x0000013769653198>
print(list(result)) # [1, 4, 9, 16, 25]

reduce()：reduce(func(x,y)，lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下⼀个元素做累积计算。
注意：reduce()传⼊的参数func必须接受2个参数。

import functools
list1 = [1, 2, 3, 4, 5]
def func(a, b):
 return a + b
result = functools.reduce(func, list1)
print(result) # 15

filter()：filter(func, lst)函数⽤于过滤序列, 过滤掉不符合条件的元素, 返回⼀个 filter 对象。如果要转换为列表,可以使⽤ list() 来转换

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def func(x):
 return x % 2 == 0
result = filter(func, list1)
print(result) # <filter object at 0x0000017AF9DC3198>
print(list(result)) # [2, 4, 6, 8, 10]

16.文件操作
⽂件操作步骤

• 打开

文件对象 = open(⽬标⽂件, 访问模式)

操作

• 读

文件对象.read()
⽂件对象.readlines()
⽂件对象.readline()

• 写

⽂件对象.write()

关闭

⽂件对象.close()

主访问模式
w：写，⽂件不存在则新建该⽂件
r：读，⽂件不存在则报错
a：追加
⽂件和⽂件夹操作
重命名：os.rename()
获取当前⽬录：os.getcwd()
获取⽬录列表：os.listdir()
17.面向对象
18.异常
异常语法

try:
 可能发⽣异常的代码
except:
 如果出现异常执⾏的代码
else:
 没有异常执⾏的代码
finally:
 ⽆论是否异常都要执⾏的代码

捕捉异常

except 异常类型:
 代码
except 异常类型 as xx:
 代码

自定义异常

# 1. ⾃定义异常类
class 异常类类名(Exception):
 代码
 
 # 设置抛出异常的描述信息
 def __str__(self):
 return ...
# 2. 抛出异常
raise 异常类名()
# 捕获异常
except Exception..

19.模块和包
导入模块

import 模块名
from 模块名 import ⽬标
from 模块名 import *

导入包

import 包名.模块名
from 包名 import *

新建包后会自己创建 __init__.py 文件，在 init.py ⽂件中添加 __all__ = [] ，控制包的导入行为
__all__ = [] 允许导⼊的模块或功能列表