Python 基础知识提纲

1 Python开发环境安装

• Python解释器
  • 解释器的作用
  • 解释器的种类
  • CPython：C语言开发的解释器，应用最为广泛。
  • IPython：基于CPython的一种交互式解释器。
  • 其他解释器
    • PyPy：基于Python语言开发的解释器。
    • JPython：运行在Java平台的解释器，直接把Python代码编译成Java字节码执行。
    • IronPython：运行在微软dotnet平台上的Python解释器，可以直接把Python代码编译成dotnet字节码执行。
• Python常用IDE：
  • Pycharm
  • 修改外观
    1. 字体，字号，行距，配色（主题）
    2. 开启Ctrl+滚轮方所编辑器字体
    3. 关闭弱警告等提示（可选）
  • 修改解释器
  • 项目管理
  • VS Code

2 Python基础知识

• 注释
• 变量
  • 命名规范：
  • 数字字母下划线；
  • 非数字开头；
  • 非内置关键字；
  • 大小写敏感。
  • 命名习惯：
  • 见名知义
  • 大驼峰：MyName
  • 小驼峰：myName
  • 下划线：my_name
• 调试
  • 断点
  • Debug

3 Python数据类型和常用操作

数据类型

输出

格式化符号

技巧

• %06d，表示输出的整数显示位数，不足以0补全，超出当前位数则原样输出
• %.2f，表示小数点后显示的小数位数。

实例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

age = 18 
name = 'TOM'
weight = 75.5
student_id = 1

# 我的名字是TOM
print('我的名字是%s' % name)

# 我的学号是0001
print('我的学号是%4d' % student_id)

# 我的体重是75.50公斤
print('我的体重是%.2f公斤' % weight)

# 我的名字是TOM，今年18岁了
print('我的名字是%s，今年%d岁了' % (name, age))

# 我的名字是TOM，明年19岁了
print('我的名字是%s，明年%d岁了' % (name, age + 1))

# 我的名字是TOM，明年19岁了
print(f'我的名字是{name}, 明年{age + 1}岁了')

f表达式

f-格式化字符串是Python3.6新增的格式化方法，简单易读。

1

f'{表达式}'

转义字符

• \n：换行。
• \t：制表符，一个Tab键（4个空格）的距离。

结束符

想一想，为什么两个 print 会换行输出？

1

print('输出的内容', end="\n")

在 Python 中，print() 默认自带end="\n"这个换行结束符，所以导致每两个print()直接会换行展示，用户可以按需求更改结束符。

输入

注意

• 当程序执行到input，等待用户输入，输入完成之后才继续向下执行。
• 在 Python 中，input接收用户输入后，一般存储到变量，方便使用。

• 在 Python 中，input会把接收到的任意用户输入的数据都当做字符串处理。

  1	input('请输入您的密码:')

数据类型转换

实例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# str() -- 转换成字符串类型
num2 = 10
print(type(str(num2)))

# tuple() -- 将一个序列转换成元组
list1 = [10, 20, 30]
print(tuple(list1))
print(type(tuple(list1)))


# list() -- 将一个序列转换成列表
t1 = (100, 200, 300)
print(list(t1))
print(type(list(t1)))

# eval() -- 将字符串中的数据转换成Python表达式原本类型
str1 = '10'
str2 = '[1, 2, 3]'
str3 = '(1000, 2000, 3000)'
print(type(eval(str1)))
print(type(eval(str2)))
print(type(eval(str3)))

运算符

见《Python运算符》

4 Python基本语句

条件语句

• if语句语法

  1 2	if condition_1: statement_block_1

• if…else…

  1 2 3 4

  if condition_1: statement_block_1 else: statement_block_3

• 多重判断

  1 2 3 4 5 6

  if condition_1: statement_block_1 elif condition_2: statement_block_2 else: statement_block_3

• if嵌套

  1 2 3 4

  if condition_1: statement_block_1 if condition_2: statement_block_2

循环语句

• 循环的作用：控制代码重复执行

• while语法

  1 2 3 4

  while condition: statement_block_1 statement_block_2 ......

• while循环嵌套语法

  1 2 3 4 5 6

  while condition1: statement_block_1 ...... while condition2: statement_block_2 ......

• for循环语法

  1 2 3 4

  for 临时变量 in 序列: 重复执行的代码1 重复执行的代码2 ......

• break退出整个循环

• continue退出本次循环，继续执行下一次重复执行的代码

• else

  • while和for都可以配合else使用
  • else下方缩进的代码含义：当循环正常结束后执行的代码
  • break终止循环不会执行else下方缩进的代码
  • continue退出循环的方式执行else下方缩进的代码

循环实例

1
2
3
4
5
6
7
8

str1 = 'itheima'
for i in str1:
    if i == 'e':
        print('遇到e不打印')
        break    ###退出整个for循环
    print(i)
else:
    print('循环正常结束之后执行的代码')

1
2
3
4
5
6
7
8

str1 = 'itheima'
for i in str1:
    if i == 'e':
        print('遇到e不打印')
        continue   ###退出if循环
    print(i)
else:
    print('循环正常结束之后执行的代码')

5 Python数据序列

集合（set）

无序的不重复元素序列

🔔建

创建集合使用{}或set()， 但是如果要创建空集合只能使用set()，因为{}用来创建空字典。

🔔增

集合天然有去重功能

s1 = {10, 20, 30, 40, 50}

🔔删

s1 = {10, 20, 30, 40, 50}

🔔其他函数

s1 = {10, 20, 30, 40, 50}

列表（list）

Python 中最基本的数据结构

🔔建

• list = []

🔔访问元素

根据下标访问

• list[index]

其他函数

• index()：返回指定数据所在位置的下标。查询的数据不存在则报错。

  1	列表序列.index(数据, 开始位置下标, 结束位置下标)

  1 2 3

  name_list = ['Tom', 'Lily', 'Rose'] print(name_list.index('Lily', 0, 2))

• count()：统计指定数据在当前列表中出现的次数。

  1 2 3

  name_list = ['Tom', 'Lily', 'Rose'] print(name_list.count('Lily'))

🔔其他函数

🔔增

• append()：可以追加元素或序列，当追加的是序列的时候，序列作为一个新的元素被追加到原来的列表中

  1 2 3 4 5 6

  name_list = ['Tom', 'Lily', 'Rose'] name_list.append(['xiaoming', 'xiaohong']) # 结果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']] print(name_list)

• extend()：列表追加数据，若数据时序列，则将序列拆分成元素逐一添加

  1 2 3 4 5 6

  name_list = ['Tom', 'Lily', 'Rose'] name_list.extend(['xiaoming', 'xiaohong']) # 结果：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong'] print(name_list)

• insert()：指定位置新增数据

  1 2 3 4 5 6 7 8

  列表序列.insert(位置下标, 数据) name_list = ['Tom', 'Lily', 'Rose'] name_list.insert(1, 'xiaoming') # 结果：['Tom', 'xiaoming', 'Lily', 'Rose'] print(name_list)

🔔删

• del
  • del 列表名 删除整个列表
  • del 列表名[index] 删除指定元素

• pop()

  • list.pop(index) 删除指定下标的数据(默认为最后一个)，并返回该数据

    1 2 3 4 5 6 7 8 9

    name_list = ['Tom', 'Lily', 'Rose'] del_name = name_list.pop(1) # 结果：Lily print(del_name) # 结果：['Tom', 'Rose'] print(name_list)

• remove()

  • list.remove('元素') 删除列表中某个数据的第一匹配项

    1 2 3 4 5 6

    name_list = ['Tom', 'Lily', 'Rose'] name_list.remove('Rose') # 结果：['Tom', 'Lily'] print(name_list)

• clear()：清空列表

  1 2 3 4

  name_list = ['Tom', 'Lily', 'Rose'] name_list.clear() print(name_list) # 结果： []

元组（tuple）

元组与列表（list）类似，不同之处在于：

①元组的元素不能修改；

②组使用小括号 ( )，列表使用方括号 [ ].

🔔建

1
2
3
4
5
6
7
8

#新建一个空元组
tup1 = ()

#新建一个仅含一个元素的元组,逗号不能省，否则会被定义为原始的类型
tup2 = (46,)

#print结果为str
tup3 = ('hello')

🔔访问元素

与列表类似。

1
2
3
4
5

#访问多个元素，“左闭右开”
[左边界:右边界]

#某个值开始后面所有元素(右边界省略)
[左边界:]

🔔其他函数

🔔拼接

1
2
3
4
5
6
7
8
9

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

🔔删

元组内的元素不可被删除

• del

  1 2 3 4

  tup = ('Google', 'pwner', 1997, 2000) del tup #删除后tup对象未定义

⚠️关于元组不可变

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

tup = ('p', 'w', 'n', 'e', 'r')
tup[0] = 'g'     

# 不支持修改元素
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

# 查看内存地址
id(tup)     
4440687904
tup = (1,2,3)

# 内存地址不一样了
id(tup)
4441088800   

字典（dict）

🔔建

1
2
3
4
5
6
7

# 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

# 空字典
dict2 = {}

dict3 = dict()

🔔访问

访问某个键值

1
2
3
4
5
6
7

d = {key1 : value1, key2 : value2, key3 : value3 }

#访问key1的值
value = d['key1']

#访问key1的值
value2 = dict1.get('key1')

访问所有键名

• keys()

  1 2 3 4 5

  dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])

访问所有键值

• values()

  1 2 3 4 5

  dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} print(dict1.values()) # dict_values(['Tom', 20, '男'])

访问所有键值对

1
2
3
4
5

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

print(dict1.items()) 

# dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])

🔔遍历

遍历键名

1
2
3

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():
    print(key)

遍历键值

1
2
3

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value in dict1.values():
    print(value)

遍历键值对

1
2
3

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
    print(item)

格式化遍历键值对

1
2
3

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
    print(f'{key} = {value}')

🔔改

1

d['key1'] = 新值

🔔删

1
2
3
4
5
6
7

dict = {'Name': 'Pwner', 'Age': 7, 'Class': 'First'}
 
del dict['Name'] # 删除键 'Name'

dict.clear()     # 清空字典

del dict         # 删除字典

⚠️注意

• 字典中键不能重复，若重复只保留最后一个键值对
• 字典可变，键不可变。（键不可为列表类型）

数据序列的公共操作

详见《Python序列公共操作》

推导式

可以理解为数学中，给出通项公式，快速生成一个数列。

详见《推导式》

6 Python函数

封装代码，高效的代码重用

函数使用步骤

1. 定义函数

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

2. 调用函数

   函数名()

函数的说明文档

保存函数解释说明的信息，便于在大型项目中方便直接调取说明文档。

• 写法

  def 函数名():
  """ 函数说明文档 """
      
  def sum_num(a, b):
  """ 求和函数 """
  return a + b
  
  #调取sum_num()函数的说明文档
  help(sum_num)

变量作用域

• 局部变量
• 全局变量（较少使用，一般传参实现变量的复用）

函数的参数

函数调用的时候可以传入真实数据，增大函数的使用的灵活性

• 形参：函数定义时书写的参数(非真实数据)

• 实参：函数调用时书写的参数(真实数据)

  def sum_num(形参1, 形参2):
  """ 求和函数 """
  return a + b
  
  sun_num(实参1,实参2)

位置参数

调用函数时根据函数定义的参数位置来传递参数。

传递和定义参数的顺序及个数必须一致。

1
2
3
4
5

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('TOM', 20, '男')

关键字参数

函数调用，通过“键=值”形式加以指定。可以让函数更加清晰、容易使用。

函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。

1
2
3
4
5
6

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('Rose', age=20, gender='女')
user_info('小明', gender='男', age=16)

缺省参数

缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）。

1
2
3
4
5
6

def user_info(name, age, gender='男'):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('TOM', 20)
user_info('Rose', 18, '女')

不定长参数

不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。此时，可用包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。可变参数传递就是一个组包的过程。

• 包裹位置传递

收集所有位置参数，返回一个元组。

传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是包裹位置传递。

1
2
3
4
5
6
7
8

def user_info(*args):
    print(args)


# ('TOM',)
user_info('TOM')
# ('TOM', 18)
user_info('TOM', 18)

• 包裹关键字传递

收集所有关键字参数，返回一个字典

1
2
3
4
5
6

def user_info(**kwargs):
    print(kwargs)


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

拆包

• 拆包：元组

  1 2 3 4 5 6 7

  def return_num(): return 100, 200 num1, num2 = return_num() print(num1) # 100 print(num2) # 200

• 拆包：字典

  1 2 3 4 5 6 7 8 9

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

函数的返回值

1
2
3
4

def log():
   print('hello')
   return 1   #退出函数
   return 2   #不执行此行

多个返回值

1. return a, b写法，返回多个数据的时候，默认是元组类型。
2. return后面可以连接列表、元组或字典，以返回多个值。

1
2
3
4
5
6

def return_num():
    return 1, 2


result = return_num()
print(result)  # (1, 2)

多函数程序执行流程

• 共用全局变量
• 返回值作为参数传递

引用

Python中，数据的传递都是通过引用来实现

 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

# 1. int类型
a = 1
b = a

print(b)  # 1

print(id(a))  # 140708464157520
print(id(b))  # 140708464157520

a = 2
print(b)  # 1,说明int类型为不可变类型 

print(id(a))  # 140708464157552，此时得到是的数据2的内存地址
print(id(b))  # 140708464157520


# 2. 列表
aa = [10, 20]
bb = aa

print(id(aa))  # 2325297783432
print(id(bb))  # 2325297783432


aa.append(30)
print(bb)  # [10, 20, 30], 列表为可变类型

print(id(aa))  # 2325297783432
print(id(bb))  # 2325297783432

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

def test1(a):
    print(a)
    print(id(a))

    a += a

    print(a)
    print(id(a))


# int：计算前后id值不同
b = 100
test1(b)

# 列表：计算前后id值相同
c = [11, 22]
test1(c)

可变类型与不可变类型

所谓可变类型与不可变类型是指：数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变.

• 可变类型
  • 列表
  • 字典
  • 集合
• 不可变类型
  • Number（整型，浮点型）
  • 字符串
  • 元组

lambda表达式

匿名函数。如果一个函数有一个返回值，并只有一句代码，那么可以使用lambda简化。

lambda本质上还是一个函数，所以同样遵守函数的参数和返回值的规定，即可以拥有0个或者多个参数，只有一个返回值。

语法

1

lambda 参数:表达式

实例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#编写一个函数实现两数的相加
def add(a,b):
    return a+b

print(add(2,3))



#使用lambda表达式来简化上述函数
fn1 = lambda a,b:a+b
print(fn1)          #输出fn1的内存地址
print(fn1(1,2))      #调用lambda表达式，计算2+3

lambda的不同参数形式

1.无参数

1
2

fn1 = lambda:100
print(fn1())

2.一个参数

1
2

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

3.默认参数

1
2

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

4.可变参数：*args

不定长位置参数

注意：这里的可变参数传入到lambda之后，返回值为元组。

1
2

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

5.可变参数：**kwargs

不定长关键字参数

1
2

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

lambda的应用

1.带判断的lambda

1
2

fn1 = lambda a, b: a if a > b else b
print(fn1(1000, 500))

2.列表数据按字典key的值排序

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

students = [
    {'name': 'TOM', 'age': 20},
    {'name': 'ROSE', 'age': 19},
    {'name': 'Jack', 'age': 22}
]

# 按name值升序排列
students.sort(key=lambda x: x['name'])
print(students)

# 按name值降序排列
students.sort(key=lambda x: x['name'], reverse=True)
print(students)

# 按age值升序排列
students.sort(key=lambda x: x['age'])
print(students)

高阶函数

把函数作为参数传入，这样的函数称为高阶函数，高阶函数是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式，所以具有开发速度快的特点。

实例

在Python中，abs()函数可以完成对数字求绝对值计算。

1

abs(-10)  # 10

round()函数可以完成对数字的四舍五入计算。

1
2

round(1.2)  # 1
round(1.9)  # 2

需求：任意两个数字，按照指定要求整理数字后再进行求和计算。

• 方法1

  1 2 3 4 5 6

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

• 方法2

  1 2 3 4 5 6

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

注意：两种方法对比之后，发现，方法2的代码会更加简洁，函数灵活性更高。

内置高阶函数

🔔map()

map(func, lst)，将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的列表(Python2)/迭代器(Python3)返回。

需求：计算list1序列中各个数字的2次方。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

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，lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累积计算。

注意：reduce()传入的参数func必须接收2个参数。

需求：计算list1序列中各个数字的累加和。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

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() 来转换。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

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]