python知识点简记

一、基础知识

1.字面量

代码中被写在代码中固定的值

常见类型：整数、浮点数、字符串等

例：print(字面量) print(10) print(13.14) print(“python”)

2.注释

# 单行注释 语句、小部分代码

''' 多行注释 python文件、函数

3.变量

定义格式：

变量名称 = 变量的值

4.数据

 

string 字符串类型

int 整形（有符号）

float 浮点型（有符号）

查看数据类型： type(数据或变量名)

注意：变量没有类型，但是变量中存储的数据有类型

5.数据类型转换

常见转换语句:

int(x) 将x转换为整数

float(x) 将x转换为浮点数

str(x) 将x转换为字符串

6.标识符

• 变量的名字
• 方法的名字
• 类的名字，等等

这些名字统称为标识符

规则：

1.内容限定 英文、中文、数字（不能在开头）、下划线

2.大小写敏感

3.不可使用关键字

7.运算符

1. 算数（数学）运算符 // 整除 **平方
2. 赋值运算符

8.字符串

1.三种定义

1. 单引号定义
2. name = ' “python” '
3. 双引号定义
4. name = " ‘python’ "
5. 三引号定义
6. name = """python"""

2.字符串拼接

 name = "python"

 address = “北京市”

 tel = 401029192

 print("我是" + name + ",我的地址是：" + address)

 # '+'只能拼接字符串，不能拼接字符串和其他数据类型

3.字符串格式化

方法1 %

 subject = "Python大数据"

 class_num = 57

 avg_salary = 16781.5

 message = "%s学科，北京%d期，毕业平均工资：%f" % (subject,class_num, avg_salary)

 print(message)

Python大数据学科，北京57期，毕业平均工资：16781.500000

数字精度控制

%5d 表示将整数的宽度控制在5位,不够就前面加空格

%5.2f 表示将宽度控制为5，将小数点精度设置为2

%.2f 表示不限制宽度，只设置小数点精度为2

方法2 f

 name = "python"

 set_up_year = 2006

 stock_price = 109.99

 print(f"我是{name},我成立于：{set_up_year}, 今天我股票价格是：{stock_price}")

4.表达式格式化

 print("1 * 1的结果是：%d" % (1 * 1))

 print(f"1 * 1的结果是：{1 * 1}")

 print("字符串在python中的类型是：%s" % type('字符串')

9.数据输入

input() 括号内可写提示信息

 name = input("请输入姓名：")

 print("欢迎您，%s" % name)

input 对于所有输入均看为字符串，如需要其他类型，可使用数据类型转换

二、判断

1.if语句

 if 要判断的条件:

  条件成立时，要做的事1

   条件成立时，要做的事2

   ......

2.if else语句

 if 要判断的条件:

  条件成立时，要做的事1

   条件成立时，要做的事2

   ......

 else:

  不满足条件要做的事1

  不满足条件要做的事2

  ......

3.if elif else语句

 if 条件1:

  条件1满足要做的事

   条件1满足要做的事

   ......

 elif 条件2:

  条件2满足要做的事

   条件2满足要做的事

   ......

 elif 条件N:

  条件N满足要做的事

   条件N满足要做的事

   ......

 else:

  所有条件都不满足要做的事

  所有条件都不满足要做的事

  ......

缩进很重要

三、循环

1.while循环

 while 条件:

  条件满足时，做的事情1

  条件满足时，做的事情2

  条件满足时，做的事情3

  ......

循环体内，请规划好循环的终止条件

 # 例：九九乘法表

 i = 1

 while i <= 9:

  j = 1

  while j <= i:

  print(f"{j} * {i} = {j * i}\t", end = "") # 不换行

  j += 1

  i += 1

  print() # 换行

2.for循环

 for 临时变量 in 待处理数据集:

  循环满足条件时执行的代码

range语句

range(num)

range(5) -> [0，1，2，3，4]

range(num1, num2)

range(5, 10) -> [5, 6, 7, 8, 9]

range(num1, num2, step)

range(5, 10, 2) -> [5, 7, 9]

 # 例：九九乘法表

 for i in range(1, 10):

  for j in range(1, i+1):

  print(f"{j} * {i} = {j * i}\t", end="")

  print()

3.continue 和 break

continue 终端 所在循环的当次执行，直接进入下一次

break 直接结束 所在循环

四、函数基础

提高程序复用性

函数的定义：

 def 函数名(传入参数):

  函数体

  return 返回值

建议写函数说明文档

局部变量、全局变量

 num = 200

 ​

 def test_a():

  print(f"test_a: {num}")

 def test_b():

  num = 500 # 局部变量 若要修改 全局变量，需加上关键字global

  print(f"test_b: {num}")

 

 test_a()

 test_b()

 print(num)

test_a: 200

test_b: 500

200

五、数据容器

一种可以容纳多份数据的数据类型

分类：列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

1.list列表

基本语法：

 # 字面量

 [元素1, 元素2, 元素3, 元素4, ....]

 ​

 # 定义变量

 变量名称 = [元素1, 元素2, 元素3, 元素4, ....]

 name_list = ['itheima', 'itcast', 'python']

 my_list = ['itheima', 666, True]

 ​

 #定义空列表

 变量名称 = []

 变量名称 = list()

嵌套列表：

my_list = [[1, 2, 3], [4, 5, 6]]

 print(my_list[1][1]) -> 5

下标索引：

 name_list = ['Tom', 'Lily', 'Rose']

 # 正向

 print(name_list[0])

 print(name_list[1])

 print(name_list[2])

 """

 Tom

 Lily

 Rose

 """

 ​

 # 反向

 print(name_list[-3])

 print(name_list[-2])

 print(name_list[-1])

 """

 Tom

 Lily

 Rose

 """

常用操作：

• 查找某元素下标值

语法：列表. index(元素)

• 修改特定位置的元素值

语法：列表[下标]=值

• 插入元素

语法：列表. insert(下标, 元素)

• 追加元素
• 追加一个元素
•  

语法：列表. append(元素)，将指定元素追加到列表尾部

• 追加一批元素

语法：列表.extend(其他数据容器)，取出其他容器内容依次追加

 my_list = [1, 2, 3]

 my_list.extend([4, 5, 6])

 print(my_list)  # 结果： [1, 2, 3, 4, 5, 6]

• 删除元素

语法1：del列表[下标]

语法2：列表.pop(下标) 返回被删除的元素

 my_list = ['itcast', 'itheima', 'python']

 del my_list[1]

 element = my_list.pop(1)

• 删除某元素在列表中第一个匹配项

语法：列表.remove(元素)

 my_list = [1, 2, 3, 2, 3]

 my_list.remove(2)

 print(my_list) # 结果：[1, 3, 2, 3]

• 清空列表内容

语法：列表.clear()

• 统计某元素在列表中的数量

语法：列表.count(元素)

 my_list = [1, 1, 1, 2, 3]

 print(my_list.count(1)) # 结果：3

• 统计列表内有多少元素

语法：len(列表)

•  

遍历：

 例：

 my_list = [1, 2, 3, 4, 5]

 for element in my_list:

  print(f"列表中的元素有："{element})

2.tuple元组

元组一旦定义完成，就不可修改

定义元组

 # 定义元组字面量

 (元素, 元素, ......, 元素)

 # 定义元组变量

 变量名称 = (元素, 元素, ......, 元素)

 # 定义空元组

 变量名称 = ()

 变量名称 = tuple()

• 定义包含单个元素的元组

 t = ("hello", ) # 如果不写逗号，t的类型为字符串

 print(f"t的类型是{type(t)}") # t的类型是<class 'tuple'>

• 元组的嵌套

 t = ((1, 2, 3), (4, 5, 6))

 print(f"t的类型是{type(t)}")

元组操作

1. index查找方法

语法：元组. index(元素)

1. count统计方法

语法：元组. count(元素)

1. len统计元组元素数量

语法： len(元组)

说明：虽然元组元素不可以修改，但是元组包含的列表的内容可以修改

 t1 = (1, 2, ['itcast', 'ooo'])

 t1[2][1] = 'best'

 print(t1) # 结果：(1, 2, ['itcast', 'best'])

 

3.字符串

my_str = "itheima and itcast"

 # 通过下标索引取值

 value = my_str[2]

 value2 = my_str[-16]

 printf(f"从字符串{my_str}中，取下标为2的元素值是：{value},取下标为-16的元素值是：{value2}")

 # 输出结果：从字符串itheima and itcast中，取下标为2的元素值是：h,取下标为-16的元素值是：h

字符串是一个 无法修改（只读）的数据容器

字符串常用操作：

1. index方法

 value = my_str.index("and")

 printf(f"在字符串{my_str}中查找and，其起始下表是：{value}")

 # 输出结果：在字符串itheima and itcast中查找and，其起始下表是：8

1. replace方法(得到新字符串)

 new_my_str = my_str.replace("it", "程序")

 printf(f"将字符串{my_str}进行替换后新字符串为：{new_my_str}")

 # 输出结果：将字符串itheima and itcast进行替换后新字符串为：itheima and 程序cast

1. split方法

 my_str = "hello python itheima itcast"

 my_str_list = my_str.split(" ")

 printf(f"将字符串{my_str}进行split切分后得到：{my_str_list},类型是：{type(my_str_list)}")

 # 输出结果：将字符串hello python itheima itcast进行split切分后得到：['hello', 'python', 'itheima', 'itcast'],类型是：<class 'list'>

1. strip方法（去前后指定字符串）

 my_str = " itheima and itcast "

 new_my_str = my_str.strip() # 不传参，去除首尾空格

 print(f"new_my_str为{new_my_str}") # new_my_str为itheima and itcast

 ​

 my_str = "12itheima and itcast21"

 new_my_str = my_str.strip("12") # 相当于去除首尾的字符串1和字符串2

 print(f"new_my_str为{new_my_str}") # new_my_str为itheima and itcast

字符串常用操作汇总：

 

4.序列

1. 定义：内容连续、有序、可使用下标索引的一类数据容器

列表、元组、字符串都可以视为数列

1. 切片：从一个序列中取出一个子序列

语法：序列[起始下标:结束下标:步长]

起始下标：从何处开始，留空表示从头(0)开始

结束下标：到何处结束（不含），留空表示截取到结尾

步长：依次取元素的间隔，负数表示反向取（起始和结束下标也要反向标记）,留空表示步长为1

 """

 将字符串my_str=”万过薪月，nohtyp学“，使用任何方式得到 "学python"

 # 方法1 先倒序后切片

 result1 = my_str[::-1][0:6]

 # 方法2 先切片后倒序

 result2 = my_str[5:11][::-1]

 # 方法3 利用字符串常用方法

 new_str = my_str[::-1]

 my_list = new_str.split("，")

 # result3 = my_list

 print(f"原始字符串为：{my_str},最终结果是：{result3}")

 # 原始字符串为：万过薪月，nohtyp学,最终结果是：学python

5.集合

不支持元素重复，并且内容无序（不支持下标索引访问），允许修改

1. 定义

 # 定义集合字面量

 {元素,元素,......,元素}

 # 定义集合变量

 变量名称 = {元素,元素,......,元素}

 # 定义空集合

 变量名称 = set()

1. 常用操作

添加元素：集合.add(元素)

移除元素：集合.remove(元素)

随机取元素：集合.pop() # 每次运行都有可能取出不同的值，取完会返回值并从元集合去除元素

清空集合：集合.clear()

取两个集合从的差集：集合1.difference(集合2)

消除差集：集合1.difference_update(集合2) # 在集合1内删除和集合2相同的元素（集合1被修改，集合2不变）

求两个集合并集：集合1.union(集合2) # 合并后得到新集合，集合1、2不变

统计集合元素数量：len()

遍历：for element in 集合:

 

6.字典

定义

 # 定义字典字面量

 {key: value, key: value, ......, key: value}

 # 定义字典变量

 my_dict = {key: value, key: value, ......, key: value}

 # 定义空字典

 my_dict = {}

 my_dict = dict()

字典数据的获取

 # 语法：字典[key]可以取到对应的value

 stu_score = {"小明": 99, "小刚": 88, "小红":77}

 print(stu_score["小刚"]) # 88

字典的嵌套

key和value可以是任意数据类型（key不可为字典）

 # 定义嵌套字典

 stu_score_dict = {

  "小明":{

  "语文":99

  "数学":18

  "英语":76

  },

  "小刚":{

  "语文":89

  "数学":32

  "英语":34

  },

  "小红":{

  "语文":88

  "数学":97

  "英语":23

  }

 }

 print(stu_score_dict["小明"]["语文"])

字典的常用操作总结：

 

7.总结

数据容器分类

• 是否支持下标索引
• 支持：列表、元组、字符串（序列类型）
• 不支持：集合、字典（非序列类型）
• 是否支持重复元素
• 支持：列表、元组、字符串（序列类型）
• 不支持：集合、字典（非序列类型）
• 是否可以修改
• 支持：列表、集合、字典
• 不支持：元组、字符串

基于各类数据容器的特点，它们的应用场景如下:

• 列表： 一批数据，可修改、可重复的存储场景
• 元组：一批数据，不可修改、可重复的存储场景
• 字符串：一串字符串的存储场景
• 集合：一批数据，去重存储场景
• 字典：一批数据，可用Key检索Value的存储场景

 

数据容器的通用操作

 

六、函数进阶

1.多返回值

 def test_return():

  return 1, 2 #逗号隔开即可

 ​

 x, y = test_return()

 print(x)

 print(y)

2.多种参数

1.位置参数

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

 def user_info(name, age, gender):

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

 ​

 user_info('Tom', 18, '男')

 # 传递的参数(实参)和定义的参数(形参)必须对应一致

2.关键字参数

调用函数时通过“键=值”的形式传递参数、

 def user_info(name, age, gender):

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

   

 # 关键字传参

 user_info(name='Tom', age=18, gender='男')

 # 可调换顺序

 user_info(age=18, gender='男', name='Tom')

 # 可和位置参数混用，但位置参数必须在前前，且对应形参顺序,关键字参数之间则不用在意顺序

 user_info('Tom', gender='男', age=18)

3.缺省参数

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

 def user_info(name, age, gender='男'):

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

 ​

 # 默认参数必须在最后

 def user_info(name, gender, age=18):

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

   

 user_info('Tom', 18)

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

4.不定长参数

也叫可变参数 ，用于不确定调用时传递多少个参数

 # 位置传递的不定长

 def user_info(*args) # 传进来的所有参数都会被元组类型的变量args收集

  print(args)

   

 user_info('Tom')

 user_info('Rose', 18)

 ​

 # 关键字传递的不定长

 def user_info(**kwargs) # 传进来的所有参数都会被字典类型的变量kwargs收集

  print(kwargs)

   

 user_info(name='Tom', age=18, id=110)

3.匿名函数

1.函数作为参数传递（计算逻辑的传递）

 def test_func(compute):

   result = compute(1, 2)

   print(result)

 ​

 def compute(x, y):

   return x + y

 ​

 test_func(compute) #输出：3

2.lambda匿名函数

定义匿名函数（无函数名称），只可临时使用一次

lambda 形式参数：函数体(一行代码)

 def test_func(compute):

   result = compute(1, 2)

   print(result)

   

 test_func(lambda x, y: x + y) #输出：3