Python基础语法

window安装Python

下载安装包

下载地址:https://www.python.org/downloads/
image.png

安装

  1. 点击下载的.exe文件并且添加环境变量

image.png

  1. 下一步全部勾选

image.png

第三步:nstall for all users :勾选 给所有用户

Associate files with python:关联python文件

create shortcuts for installed applications:给安装的软件,添加个快捷方式

add python to enviroment variables:将python添加到环境变量中

Precompile standard library:预编译[准备]python标准文件

Customize install location:本地安装位置

最后两个选项不需要勾选,其余的都勾选。

image.png

验证

  1. python

image.png

pyCharm

PyCharm安装

下载地址:https://www.jetbrains.com/pycharm/download/other.html
image.png

注:注意勾选下图的两处

image.png

Pycharm新建项目

image.png

Pycharm配置

配置字体

[Editor] — [Font]

Font:修改字体

Size:修改字号

Line Spacing:修改⾏间距

image.png

配置解析器

image.png

Python语法

变量

定义变量

image.png

  1. a = 1
  2. print(type(a)) # <class 'int'> -- 整型
  3. b = 1.1
  4. print(type(b)) # <class 'float'> -- 浮点型
  5. c = True
  6. print(type(c)) # <class 'bool'> -- 布尔型
  7. d = '12345'
  8. print(type(d)) # <class 'str'> -- 字符串
  9. e = [10, 20, 30]
  10. print(type(e)) # <class 'list'> -- 列表
  11. f = (10, 20, 30)
  12. print(type(f)) # <class 'tuple'> -- 元组
  13. h = {10, 20, 30}
  14. print(type(h)) # <class 'set'> -- 集合
  15. g = {'name': 'TOM', 'age': 20}
  16. print(type(g)) # <class 'dict'> -- 字典

输出变量

格式化符号

格式符号 转换
%s 字符串
%d 有符号的⼗进制整数
%f 浮点数
%c 字符
%u ⽆符号⼗进制整数
%o ⼋进制整数
%x ⼗六进制整数(⼩写ox)
%X ⼗六进制整数(⼤写OX)
%e 科学计数法(⼩写’e’)
格式符号 转换
%E 科学计数法(⼤写’E’)
%g %f和%e的简写
%G %f和%E的简写

技巧

%06d,表示输出的整数显示位数,不⾜以0补全,超出当前位数则原样输出

%.2f,表示⼩数点后显示的⼩数位数。

输出变量

技巧

%06d,表示输出的整数显示位数,不⾜以0补全,超出当前位数则原样输出

%.2f,表示⼩数点后显示的⼩数位数。

f- 格式化字符串是Python3.6中新增的格式化⽅法,该⽅法更简单易读。

转义字符

  • n :换⾏。
  • t :制表符,⼀个tab键(4个空格)的距离。

结束符

在Python中,print(), 默认⾃带 end=”\n” 这个换⾏结束符,所以导致每两个 print 直接会换⾏展示,⽤户可以按需求更改结束符。

  1. age = 18
  2. name = 'TOM'
  3. weight = 75.5
  4. student_id = 1
  5. # 我的名字是TOM
  6. print('我的名字是%s' % name)
  7. # 我的学号是0001 补全位数 由1转换成0001
  8. print('我的学号是%4d' % student_id)
  9. # 我的体重是75.50公⽄
  10. print('我的体重是%.2f公⽄' % weight)
  11. # 我的名字是TOM,今年18岁了
  12. print('我的名字是%s,今年%d岁了' % (name, age))
  13. # 我的名字是TOM,明年19岁了
  14. print('我的名字是%s,明年%d岁了' % (name, age + 1))
  15. # 我的名字是TOM,明年19岁了
  16. # f-格式化字符串是Python3.6中新增的格式化⽅法,该⽅法更简单易读。
  17. print(f'我的名字是{name}, 明年{age + 1}岁了')
  18. ##### 转移符号
  19. # 换行转义\n
  20. print('我的名字是\nGG')
  21. # 结束符 \t ⼀个tab键(4个空格)的距离
  22. print('我的名字是\tGG')
  23. #### 结束符
  24. print('输出的内容1', end="\n")
  25. print('输出的内容2', end="\t")
  26. print('输出的内容3', end="\t")

input 输入函数

输入函数例子

  1. password = input('请输⼊您的密码:')
  2. print(f'您输⼊的密码是{password}')
  3. # <class 'str'>
  4. print(type(password))

转换数据类型

函数 说明
int(x [,base ]) 将x转换为⼀个整数
flfloat(x) 将x转换为⼀个浮点数
str(x) 将对象 x 转换为字符串
eval(str) ⽤来计算在字符串中的有效Python表达式,并返回⼀个对象
tuple(s) 将序列 s 转换为⼀个元组
list(s) 将序列 s 转换为⼀个列表
  1. # 1. 接收⽤户输⼊
  2. num = input('请输⼊您的幸运数字:')
  3. # 2. 打印结果
  4. print(f"您的幸运数字是{num}")
  5. # 3. 检测接收到的⽤户输⼊的数据类型 -- str类型
  6. print(type(num))
  7. # 4. 转换数据类型为整型 -- int类型
  8. print(type(int(num)))

运算符

  • 算数运算的优先级
    • 混合运算优先级顺序: () ⾼于 * ⾼于 / // % ⾼于 + -
  • 赋值运算符
    • =
  • 复合赋值运算符
    • +=
    • -=
    • 优先级
  1. 1. 先算复合赋值运算符右侧的表达式
  1. * 2.再算复合赋值运算的算数运算
  2. * 3.最后算赋值运算
  • ⽐较运算符
    • 判断相等: ==
    • ⼤于等于: >=
    • ⼩于等于:<=
    • 不等于: !=
  • 逻辑运算符
    • 与: and
    • 或:or
    • ⾮:not

条件语句(if+三目)

三⽬运算符也叫三元运算符或三元表达式

  1. a = 1 b = 2 c = a if a > b else b
  2. print(c)
  1. # 导⼊random模块
  2. import random
  3. # 计算电脑出拳的随机数字
  4. computer = random.randint(0, 2)
  5. print(computer)
  6. player = int(input('请出拳:0-⽯头,1-剪⼑,2-布:'))
  7. # 玩家胜利 p0:c1 或 p1:c2 或 p2:c0
  8. if ((player == 0) and (computer == 1)) or ((player == 1) and (computer == 2)) or ((player == 2) and (computer == 0)):
  9. print('玩家获胜')
  10. # 平局:玩家 == 电脑
  11. elif player == computer:
  12. print('平局')
  13. else:
  14. print('电脑获胜')

while循环

  1. j = 0
  2. while j < 3:
  3. i = 0
  4. while i < 3:
  5. print('媳妇⼉,我错了')
  6. i += 1
  7. print('刷晚饭的碗')
  8. print('⼀套惩罚结束----------------')
  9. j += 1

字符串

基础用法

  1. name1 = 'Tom'
  2. name2 = "Rose"
  3. # 注意:三引号形式的字符串⽀持换⾏。
  4. name3 = ''' Tom '''
  5. name4 = """ Rose """
  6. a = ''' i am Tom,
  7. nice to meet you! '''
  8. b = """ i am Rose,
  9. nice to meet you! """

下标

  1. name = "abcdef"
  2. print(name[1])
  3. print(name[0])
  4. print(name[2])

切⽚

  1. ## 切⽚是指对操作的对象截取其中⼀部分的操作。字符串、列表、元组都⽀持切⽚操作
  2. ## 序列[开始位置下标:结束位置下标:步⻓]
  3. ## 注意
  4. ## 1. 不包含结束位置下标对应的数据, 正负整数均可;
  5. ## 2. 步⻓是选取间隔,正负整数均可,默认步⻓为1。
  1. print(name[2:5:1]) # cde
  2. print(name[2:5]) # cde
  3. print(name[:5]) # abcde
  4. print(name[1:]) # bcdefg
  5. print(name[:]) # abcdefg
  6. print(name[::2]) # aceg
  7. print(name[:-1]) # abcdef, 负1表示倒数第⼀个数据
  8. print(name[-4:-1]) # def
  9. print(name[::-1]) # gfedcba

常⽤操作⽅法

  • 字符串序列.find(⼦串, 开始位置下标, 结束位置下标)
  • index():检测某个⼦串是否包含在这个字符串中,如果在返回这个⼦串开始的位置下标,否则则报异常。
  • join():⽤⼀个字符或⼦串合并字符串,即是将多个字符串合并为⼀个新的字符串。
  • isspace():如果字符串中只包含空⽩,则返回 True,否则返回 False。
  1. ## 查找
  2. ## 字符串序列.find(⼦串, 开始位置下标, 结束位置下标)
  3. mystr = "hello world and itcast and itheima and Python"
  4. print(mystr.find('and')) # 12
  5. print(mystr.find('and', 15, 30)) # 23
  6. print(mystr.find('ands')) # -1
  7. ## index():检测某个⼦串是否包含在这个字符串中,如果在返回这个⼦串开始的位置下标,否则则报异常。
  8. mystr = "hello world and itcast and itheima and Python"
  9. print(mystr.index('and')) # 12
  10. print(mystr.index('and', 15, 30)) # 23
  11. print(mystr.index('ands')) # 报错
  12. ## rfind(): 和find()功能相同,但查找⽅向为右侧开始。
  13. ## rindex():和index()功能相同,但查找⽅向为右侧开始。
  14. ## count():返回某个⼦串在字符串中出现的次数
  15. mystr = "hello world and itcast and itheima and Python"
  16. print(mystr.count('and')) # 3
  17. print(mystr.count('ands')) # 0
  18. print(mystr.count('and', 0, 20)) # 1
  19. ## join():⽤⼀个字符或⼦串合并字符串,即是将多个字符串合并为⼀个新的字符串。
  20. ## 修改
  21. list1 = ['chuan', 'zhi', 'bo', 'ke']
  22. t1 = ('aa', 'b', 'cc', 'ddd')
  23. # 结果:chuan_zhi_bo_ke
  24. print('_'.join(list1))
  25. # 结果:aa...b...cc...ddd
  26. print('...'.join(t1))
  27. ## 判断
  28. ## startswith():检查字符串是否是以指定⼦串开头,是则返回 True,否则返回 False。如果设置开始和结束位置下标,则在指定范围内检查。
  29. mystr = "hello world and itcast and itheima and Python "
  30. # 结果:True
  31. print(mystr.startswith('hello'))
  32. # 结果False
  33. print(mystr.startswith('hello', 5, 20))
  34. ## endswith()::检查字符串是否是以指定⼦串结尾,是则返回 True,否则返回 False。如果设置开始和结束位置下标,则在指定范围内检查
  35. mystr = "hello world and itcast and itheima and Python"
  36. # 结果:True
  37. print(mystr.endswith('Python'))
  38. # 结果:False
  39. print(mystr.endswith('python'))
  40. # 结果:False
  41. print(mystr.endswith('Python', 2, 20))
  42. ## isalpha():如果字符串⾄少有⼀个字符并且所有字符都是字⺟则返回 True, 否则返回 False。
  43. mystr1 = 'hello'
  44. mystr2 = 'hello12345'
  45. # 结果:True
  46. print(mystr1.isalpha())
  47. # 结果:False
  48. print(mystr2.isalpha())
  49. ## isdigit():如果字符串只包含数字则返回 True 否则返回 False
  50. mystr1 = 'aaa12345'
  51. mystr2 = '12345'
  52. # 结果: False
  53. print(mystr1.isdigit())
  54. # 结果:False
  55. print(mystr2.isdigit())
  56. ## isalnum():如果字符串⾄少有⼀个字符并且所有字符都是字⺟或数字则返 回 True,否则返回False。
  57. mystr1 = 'aaa12345'
  58. mystr2 = '12345-'
  59. # 结果:True
  60. print(mystr1.isalnum())
  61. # 结果:False
  62. print(mystr2.isalnum())
  63. ## isspace():如果字符串中只包含空⽩,则返回 True,否则返回 False。

列表

基础用法

name_list = [‘Tom’, ‘Lily’, ‘Rose’]

  • index():返回指定数据所在位置的下标
  • count():统计指定数据在当前列表中出现的次数
  • len():访问列表⻓度,即列表中数据的个数
  • in 判断是否存在
  • not in:判断指定数据不在某个列表序列,如果不在返回True,否则返回False
  • append():列表结尾追加数据
  • pop():删除指定下标的数据(默认为最后⼀个),并返回该数据
  • remove():移除列表中某个数据的第⼀个匹配项
  • clear():清空列表
  • reverse():逆置列表
  • sort():排序
  • copy():复制
  1. name_list = ['Tom', 'Lily', 'Rose']
  2. print(name_list[0]) # Tom
  3. print(name_list[1]) # Lily
  4. print(name_list[2]) # Rose
  5. # index():返回指定数据所在位置的下标
  6. name_list = ['Tom', 'Lily', 'Rose']
  7. print(name_list.index('Lily', 0, 2)) # 1
  8. # count():统计指定数据在当前列表中出现的次数
  9. name_list = ['Tom', 'Lily', 'Rose']
  10. print(name_list.count('Lily')) # 1
  11. # len():访问列表⻓度,即列表中数据的个数
  12. name_list = ['Tom', 'Lily', 'Rose']
  13. print(len(name_list)) # 3
  14. # in 判断是否存在
  15. name_list = ['Tom', 'Lily', 'Rose']
  16. # 结果:True
  17. print('Lily' in name_list)
  18. # 结果:False
  19. print('Lilys' in name_list)
  20. # not in:判断指定数据不在某个列表序列,如果不在返回True,否则返回False
  21. name_list = ['Tom', 'Lily', 'Rose']
  22. # 结果:False
  23. print('Lily' not in name_list)
  24. # 结果:True
  25. print('Lilys' not in name_list)
  26. # append():列表结尾追加数据。
  27. name_list = ['Tom', 'Lily', 'Rose']
  28. name_list.append('xiaoming')
  29. # 结果:['Tom', 'Lily', 'Rose', 'xiaoming']
  30. print(name_list)
  31. name_list.append(['xiaoming', 'xiaohong'])
  32. # 结果:['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]
  33. print(name_list)
  34. name_list.insert(1, 'xiaoming')# 位置下标, 数据
  35. name_list = ['Tom', 'Lily', 'Rose']
  36. # 结果:报错提示:name 'name_list' is not defined
  37. del name_list
  38. print(name_list)
  39. del name_list[0]
  40. # 结果:['Lily', 'Rose']
  41. print(name_list)
  42. # pop():删除指定下标的数据(默认为最后⼀个),并返回该数据
  43. del_name = name_list.pop(1)
  44. # remove():移除列表中某个数据的第⼀个匹配项
  45. name_list = ['Tom', 'Lily', 'Rose']
  46. name_list.remove('Rose')
  47. # 结果:['Tom', 'Lily']
  48. print(name_list)
  49. # clear():清空列表
  50. name_list = ['Tom', 'Lily', 'Rose']
  51. name_list.clear()
  52. print(name_list) # 结果: []
  53. # 逆置:reverse()
  54. num_list = [1, 5, 2, 3, 6, 8]
  55. num_list.reverse()
  56. # 结果:[8, 6, 3, 2, 5, 1]
  57. print(num_list)
  58. # 排序:sort()
  59. num_list = [1, 5, 2, 3, 6, 8]
  60. num_list.sort()
  61. # 结果:[1, 2, 3, 5, 6, 8]
  62. print(num_list)
  63. # 复制:copy()
  64. name_list = ['Tom', 'Lily', 'Rose']
  65. name_li2 = name_list.copy()
  66. # 结果:['Tom', 'Lily', 'Rose']
  67. print(name_li2)
  68. #For
  69. name_list = ['Tom', 'Lily', 'Rose']
  70. for i in name_list:
  71. print(i)
  72. # 列表嵌套
  73. name_list = [['⼩明', '⼩红', '⼩绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]
  74. # 第⼀步:按下标查找到李四所在的列表
  75. print(name_list[2])
  76. # 第⼆步:从李四所在的列表⾥⾯,再按下标找到数据李四
  77. print(name_list[2][1])

元组

列表可以⼀次性存储多个数据,但是列表中的数据允许更改。

⼀个元组可以存储多个数据,元组内的数据是不能修改的。

定义元组

  1. ## 元组特点:定义元组使⽤⼩括号,且逗号隔开各个数据,数据可以是不同的数据类型。
  2. # 多个数据元组
  3. t1 = (10, 20, 30)
  4. # 单个数据元组
  5. t2 = (10,)
  6. # 如果定义的元组只有⼀个数据,那么这个数据后⾯也好添加逗号,否则数据类型为唯⼀的这个数据的数据类型
  7. t2 = (10,)
  8. print(type(t2)) # tuple
  9. t3 = (20)
  10. print(type(t3)) # int
  11. t4 = ('hello')
  12. print(type(t4)) # str

常见操作

  1. ## 元组数据不⽀持修改,只⽀持查找
  2. tuple1 = ('aa', 'bb', 'cc', 'bb')
  3. print(tuple1[0]) # aa
  4. ## 按下标查找数据
  5. tuple1 = ('aa', 'bb', 'cc', 'bb')
  6. print(tuple1[0]) # aa
  7. ## index():查找某个数据,如果数据存在返回对应的下标,否则报错,语法和列表、字符串的index⽅法相同。
  8. tuple1 = ('aa', 'bb', 'cc', 'bb')
  9. print(tuple1.index('aa')) # 0
  10. ## count():统计某个数据在当前元组出现的次数
  11. tuple1 = ('aa', 'bb', 'cc', 'bb')
  12. print(tuple1.count('bb')) # 2
  13. ## len():统计元组中数据的个数。
  14. tuple1 = ('aa', 'bb', 'cc', 'bb')
  15. print(len(tuple1)) # 4
  16. ## 如果元组⾥⾯有列表,修改列表⾥⾯的数据则是⽀持的,故⾃觉很重要
  17. tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
  18. print(tuple2[2]) # 访问到列表
  19. # 结果:(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
  20. tuple2[2][0] = 'aaaaa'
  21. print(tuple2)

集合

特点:

  1. 集合可以去掉重复数据;
  2. 集合数据是⽆序的,故不⽀持下标
  1. ## 创建集合
  2. ## {50, 20, 40, 10, 30}
  3. s1 = {10, 20, 30, 40, 50}
  4. print(s1)
  5. ## {50, 20, 40, 10, 30}
  6. s2 = {10, 30, 20, 10, 30, 40, 30, 50}
  7. print(s2)
  8. ## {'g', 'd', 'a', 'b', 'c', 'e', 'f'}
  9. s3 = set('abcdefg')
  10. print(s3)

常见操作

  1. ## 集合有去重功能,所以,当向集合内追加的数据是当前集合已有数据的话,则不进⾏任何操作。
  2. ## add() 添加集合
  3. s1 = {10, 20}
  4. s1.add(100)
  5. s1.add(10)
  6. print(s1) # {100, 10, 20}
  7. ## update(), 追加的数据是序列。
  8. s1 = {10, 20}
  9. # s1.update(100) # 报错
  10. s1.update([100, 200])
  11. s1.update('abc')
  12. print(s1)
  13. ## 删除数据 remove(),删除集合中的指定数据,如果数据不存在则报错。
  14. s1 = {10, 20}
  15. s1.remove(10)
  16. print(s1)
  17. s1.remove(10) # 报错
  18. print(s1)
  19. ## discard(),删除集合中的指定数据,如果数据不存在也不会报错。
  20. s1 = {10, 20}
  21. s1.discard(10)
  22. print(s1)
  23. s1.discard(10)
  24. print(s1)
  25. ## pop(),随机删除集合中的某个数据,并返回这个数据。
  26. s1 = {10, 20, 30, 40, 50}
  27. del_num = s1.pop()
  28. print(del_num)
  29. print(s1)
  30. ## in:判断数据在集合序列
  31. ## not in:判断数据不在集合序列
  32. s1 = {10, 20, 30, 40, 50}
  33. print(10 in s1)
  34. print(10 not in s1)

字典

定义字典

字典特点:

  • 符号为⼤括号
  • 数据为键值对形式出现
  • 各个键值对之间⽤逗号隔开

字典⾥⾯的数据是以键值对形式出现,字典数据和数据顺序没有关系,即字典不⽀持下标,后期⽆论数据如何变化,只需要按照对应的键的名字查找数据即可。

  1. # 有数据字典
  2. dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
  3. # 空字典
  4. dict2 = {}
  5. dict3 = dict()

常见操作

  1. ## 增加数据
  2. dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
  3. dict1['name'] = 'Rose'
  4. # 结果:{'name': 'Rose', 'age': 20, 'gender': '男'}
  5. print(dict1)
  6. dict1['id'] = 110
  7. # {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
  8. print(dict1)
  9. ## 删除数据
  10. ## del() / del:删除字典或删除字典中指定键值对。
  11. dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
  12. del dict1['gender']
  13. # 结果:{'name': 'Tom', 'age': 20}
  14. print(dict1)
  15. ## clear():清空字典
  16. dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
  17. dict1.clear()
  18. print(dict1) # {}
  19. ## 修改数据
  20. ## 如果key存在则修改这个key对应的值 ;如果key不存在则新增此键值对。
  21. # 有数据字典
  22. dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
  23. dict1['name']='Jack'
  24. print(dict1)
  25. ## 查找数据
  26. ## 如果当前查找的key存在,则返回对应的值;否则则报错
  27. dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
  28. print(dict1['name']) # Tom
  29. print(dict1['id']) # 报错
  30. ## get() 如果当前查找的key不存在则返回第⼆个参数(默认值),如果省略第⼆个参数,则返回None。
  31. dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
  32. print(dict1.get('name')) # Tom
  33. print(dict1.get('id', 110)) # 110
  34. print(dict1.get('id')) # None
  35. ## keys() 返回所有的key值
  36. dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
  37. print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])
  38. ## values() 返回所有的values值
  39. dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
  40. print(dict1.values()) # dict_values(['Tom', 20, '男'])
  41. ## items()
  42. dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
  43. print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender','男')])
  44. ## 字典的循环遍历
  45. dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
  46. for key in dict1.keys():
  47. print(key)
  48. ## 遍历字典的value
  49. dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
  50. for value in dict1.values():
  51. print(value)
  52. ## 遍历字典的元素
  53. dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
  54. for item in dict1.items():
  55. print(item)
  56. ## 遍历字典的键值对
  57. dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
  58. for key, value in dict1.items():
  59. print(f'{key} = {value}')

公共操作

常规函数

运算符 描述 ⽀持的容器类型
+ 合并 字符串、列表、元组
* 复制 字符串、列表、元组
in 元素是否存在 字符串、列表、元组、字典
not in 元素是否不存在 字符串、列表、元组、字典
函数 描述
len() 计算容器中元素个数
del 或 del() 删除
max() 返回容器中元素最⼤值
min() 返回容器中元素最⼩值
range(start,end, step) ⽣成从start到end的数字,步⻓为 step,供for循环使⽤
enumerate() 函数⽤于将⼀个可遍历的数据对象(如列表、元组或字符串)组合为⼀个索引序
  1. ## len()
  2. # 1. 字符串
  3. str1 = 'abcdefg'
  4. print(len(str1)) # 7
  5. # 2. 列表
  6. list1 = [10, 20, 30, 40]
  7. print(len(list1)) # 4
  8. # 3. 元组
  9. t1 = (10, 20, 30, 40, 50)
  10. print(len(t1)) # 5
  11. # 4. 集合
  12. s1 = {10, 20, 30}
  13. print(len(s1)) # 3
  14. # 5. 字典
  15. dict1 = {'name': 'Rose', 'age': 18}
  16. print(len(dict1)) # 2
  17. ## del()
  18. # 1. 字符串
  19. str1 = 'abcdefg'
  20. del str1
  21. print(str1)
  22. # 2. 列表
  23. list1 = [10, 20, 30, 40]
  24. del(list1[0])
  25. print(list1) # [20, 30, 40]
  26. ## max()
  27. # 1. 字符串
  28. str1 = 'abcdefg'
  29. print(max(str1)) # g
  30. # 2. 列表
  31. list1 = [10, 20, 30, 40]
  32. print(max(list1)) # 40
  33. ## min()
  34. # 1. 字符串
  35. str1 = 'abcdefg'
  36. print(min(str1)) # a
  37. # 2. 列表
  38. list1 = [10, 20, 30, 40]
  39. print(min(list1)) # 10
  40. ## range()
  41. ## range()⽣成的序列不包含end数字。
  42. # 1 2 3 4 5 6 7 8 9
  43. for i in range(1, 10, 1):
  44. print(i)
  45. # 1 3 5 7 9
  46. for i in range(1, 10, 2):
  47. print(i)
  48. # 0 1 2 3 4 5 6 7 8 9
  49. for i in range(10):
  50. print(i)
  51. ## enumerate()
  52. ## start参数⽤来设置遍历数据的下标的起始值,默认为0。
  53. list1 = ['a', 'b', 'c', 'd', 'e']
  54. for i in enumerate(list1):
  55. print(i)
  56. for index, char in enumerate(list1, start=1):
  57. print(f'下标是{index}, 对应的字符是{char}')

容器类型转换

  1. ## tuple() 将某个序列转换成元组
  2. list1 = [10, 20, 30, 40, 50, 20]
  3. s1 = {100, 200, 300, 400, 500}
  4. print(tuple(list1))
  5. print(tuple(s1))
  6. ## list() 作⽤:将某个序列转换成列表
  7. t1 = ('a', 'b', 'c', 'd', 'e')
  8. s1 = {100, 200, 300, 400, 500}
  9. print(list(t1))
  10. print(list(s1))
  11. ## set() 作⽤:将某个序列转换成集合
  12. list1 = [10, 20, 30, 40, 50, 20]
  13. t1 = ('a', 'b', 'c', 'd', 'e')
  14. print(set(list1))
  15. print(set(t1))
  16. #注意:
  17. #1. 集合可以快速完成列表去重
  18. #2. 集合不⽀持下标

推导式

作⽤:⽤⼀个表达式创建⼀个有规律的列表或控制⼀个有规律列表。

列表推导式⼜叫列表⽣成式。

列表推导式

  1. # for循环
  2. list1 = []
  3. for i in range(10):
  4. list1.append(i)
  5. print(list1)
  6. ## 列表推导式实现
  7. list1 = [i for i in range(10)]
  8. print(list1)
  1. # ⽅法⼀:range()步⻓实现
  2. list1 = [i for i in range(0, 10, 2)]
  3. print(list1)
  4. # ⽅法⼆:if实现
  5. list1 = [i for i in range(10) if i % 2 == 0]
  6. print(list1)

字典推导式

  1. # 如何快速合并为⼀个字典?
  2. list1 = ['name', 'age', 'gender']
  3. list2 = ['Tom', 20, 'man']
  4. ## 创建⼀个字典:字典key是1-5数字,value是这个数字的2次⽅。
  5. dict1 = {i: i**2 for i in range(1, 5)}
  6. print(dict1) # {1: 1, 2: 4, 3: 9, 4: 16}
  7. ## 将两个列表合并为⼀个字典
  8. list1 = ['name', 'age', 'gender']
  9. list2 = ['Tom', 20, 'man']
  10. dict1 = {list1[i]: list2[i] for i in range(len(list1))}
  11. print(dict1)
  12. ## 提取字典中⽬标数据
  13. counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
  14. # 需求:提取上述电脑数量⼤于等于200的字典数据
  15. count1 = {key: value for key, value in counts.items() if value >= 200}
  16. print(count1) # {'MBP': 268, 'DELL': 201}

集合推导式

  1. ##需求:创建⼀个集合,数据为下⽅列表的2次⽅。
  2. list1 = [1, 1, 2]
  3. ##代码如下:
  4. list1 = [1, 1, 2]
  5. set1 = {i ** 2 for i in list1}
  6. print(set1) # {1, 4}
  7. ##注意:集合有数据去重功能。

总结

  • 推导式的作⽤:简化代码
  • 推导式写法
  1. # 列表推导式
  2. [xx for xx in range()]
  3. # 字典推导式
  4. {xx1: xx2 for ... in ...}
  5. # 集合推导式
  6. {xx for xx in ...}

函数

定义函数

  1. # 1. 定义函数
  2. def add_num1():
  3. result = 1 + 2
  4. print(result)
  5. # 调⽤函数
  6. add_num1()
  7. # 2. 定义函数接收形参
  8. def add_num2(a, b):
  9. result = a + b
  10. print(result)
  11. # 调⽤函数
  12. add_num2(10, 20)
  13. ## 3. 函数的返回值
  14. def buy():
  15. return '烟'
  16. # 调⽤函数
  17. goods = buy()
  18. print(goods)
  19. ## 4.函数的说明⽂档
  20. def sum_num(a, b):
  21. """ 求和函数 """
  22. return a + b
  23. help(sum_num)

函数进阶

  1. ## 1. global 关键字声明a是全局变量
  2. a = 100
  3. def testA():
  4. print(a)
  5. def testB():
  6. # global 关键字声明a是全局变量
  7. global a
  8. a = 200
  9. testA() # 100
  10. testB() # 200
  11. print(f'全局变量a = {a}') # 全局变量a = 200
  12. ## 2.函数的返回值
  13. ## 2.1. return a, b 写法,返回多个数据的时候,默认是元组类型。
  14. ## 2.2. return后⾯可以连接列表、元组或字典,以返回多个值。
  15. def return_num():
  16. return 1, 2
  17. result = return_num()
  18. print(result) # (1, 2)
  19. ## 函数的参数
  20. ### 1. 位置参数
  21. ### 位置参数:调⽤函数时根据函数定义的参数位置来传递参数。
  22. def user_info(name, age, gender):
  23. print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
  24. user_info('TOM', 20, '男')
  25. ### 2. 关键字参数
  26. ### 函数调⽤,通过“键=值”形式加以指定。可以让函数更加清晰、容易使⽤,同时也清除了参数的顺序需求。
  27. def user_info(name, age, gender):
  28. print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
  29. user_info('Rose', age=20, gender='⼥')
  30. user_info('⼩明', gender='男', age=16)
  31. ### 3. 缺省参数
  32. ### 缺省参数也叫默认参数,⽤于定义函数,为参数提供默认值,调⽤函数时可不传该默认参数的值
  33. def user_info(name, age, gender='男'):
  34. print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
  35. user_info('TOM', 20)
  36. user_info('Rose', 18, '⼥')
  37. ### 4.不定⻓参数
  38. ### 不定⻓参数也叫可变参数。⽤于不确定调⽤的时候会传递多少个参数(不传参也可以)的场景。
  39. ### 注意:传进的所有参数都会被args变量收集,它会根据传进参数的位置合并为⼀个元组(tuple),args是元组类型,这就是包裹位置传递。
  40. def user_info(*args):
  41. print(args)
  42. # ('TOM',)
  43. user_info('TOM')
  44. # ('TOM', 18)
  45. user_info('TOM', 18)
  46. def user_info(**kwargs):
  47. print(kwargs)
  48. # {'name': 'TOM', 'age': 18, 'id': 110}
  49. user_info(name='TOM', age=18, id=110)
  50. # 交换变量值
  51. # 需求:有变量 a = 10 和 b = 20 ,交换两个变量的值。
  52. a, b = 1, 2
  53. a, b = b, a
  54. print(a) # 2
  55. print(b) # 1

拆包

  1. # 拆包和交换变量值
  2. ## 1. 拆包:元组
  3. def return_num():
  4. return 100, 200
  5. num1, num2 = return_num()
  6. print(num1) # 100
  7. print(num2) # 200
  8. ## 2.拆包:字典
  9. dict1 = {'name': 'TOM', 'age': 18} a, b = dict1
  10. # 对字典进⾏拆包,取出来的是字典的key
  11. print(a) # name
  12. print(b) # age
  13. print(dict1[a]) # TOM
  14. print(dict1[b]) # 18

引⽤

在python中,值是靠引⽤来传递来的。

我们可以⽤ id() id() 来判断两个变量是否为同⼀个值的引⽤。 我们可以将id值理解为那块内存的地址标识

  1. ## 我们可以⽤ id() id() 来判断两个变量是否为同⼀个值的引⽤。 我们可以将id值理解为那块内存的地址标识。
  2. # 1. int类型
  3. a = 1 b = a
  4. print(b) # 1
  5. print(id(a)) # 140708464157520
  6. print(id(b)) # 140708464157520
  7. a = 2
  8. print(b) # 1,说明int类型为不可变类型
  9. ## 引⽤当做实参
  10. def test1(a):
  11. print(a)
  12. print(id(a))
  13. a += a
  14. print(a)
  15. print(id(a))
  16. # int:计算前后id值不同
  17. b = 100
  18. test1(b)
  19. # 列表:计算前后id值相同
  20. c = [11, 22]
  21. test1(c)

可变和不可变类型

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

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

总结

函数的作⽤:封装代码,⾼效的代码重⽤

函数使⽤步骤

  • 定义函数
  1. def 函数名():
  2. 代码1
  3. 代码2
  4. ...

调⽤函数的方式

函数的参数:函数调⽤的时候可以传⼊真实数据,增⼤函数的使⽤的灵活性

  • 形参:函数定义时书写的参数(⾮真实数据)
  • 实参:函数调⽤时书写的参数(真实数据)

函数的返回值

  • 作⽤:函数调⽤后,返回需要的计算结果
  • 写法 return 表达式

函数的说明⽂档

作⽤:保存函数解释说明的信息

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

函数的参数

  • 位置参数
    • 形参和实参的个数和书写顺序必须⼀致
  • 关键字参数
    • 写法: key=value
    • 特点:形参和实参的书写顺序可以不⼀致;关键字参数必须书写在位置参数的后⾯
  • 缺省参数
    • 缺省参数就是默认参数
    • 写法: key=vlaue
  • 不定⻓位置参数
    • 收集所有位置参数,返回⼀个元组
  • 不定⻓关键字参数
    • 收集所有关键字参数,返回⼀个字典

引⽤:Python中,数据的传递都是通过引⽤

lambda表达式

应⽤场景

如果⼀个函数有⼀个返回值,并且只有⼀句代码,可以使⽤ lambda简化。

lambda语法

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

应用场景

  1. # 函数
  2. def fn1():
  3. return 200
  4. print(fn1)
  5. print(fn1())
  6. # lambda表达式
  7. fn2 = lambda: 100
  8. print(fn2)
  9. print(fn2())

计算a + b

  1. ## 函数实现
  2. def add(a, b):
  3. return a + b
  4. result = add(1, 2)
  5. print(result)
  6. ## lambda实现
  7. print((lambda a, b: a + b)(1, 2))
  1. ## lambda的参数形式
  2. ## ⽆参数
  3. print((lambda: 100)())
  4. ## ⼀个参数
  5. print((lambda a: a)('hello world'))
  6. ## 默认参数
  7. print((lambda a, b, c=100: a + b + c)(10, 20)) 1
  8. ## 可变参数:**args
  9. print((lambda *args: args)(10, 20, 30))
  10. ## 可变参数:**kwargs
  11. print((lambda **kwargs: kwargs)(name='python', age=20))
  12. print((lambda **kwargs: kwargs)(name='python', age=20))

⾼阶函数

  1. ## 把函数作为参数传⼊,这样的函数称为⾼阶函数,⾼阶函数是函数式编程的体现。函数式编程就是指这种⾼度抽象的编程范式。

map()

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

  1. ## 需求:计算 list1 序列中各个数字的2次⽅。
  2. list1 = [1, 2, 3, 4, 5]
  3. def func(x):
  4. return x ** 2
  5. result = map(func, list1)
  6. print(result) # <map object at 0x0000013769653198>
  7. print(list(result)) # [1, 4, 9, 16, 25]

reduce()

reduce(func(x,y),lst),其中func必须有两个参数。每次func计算的结果继续和序列的下⼀个元素做累

积计算。

注意:reduce()传⼊的参数func必须接受2个参数。

  1. ## 需求:计算 list1 序列中各个数字的累加和。
  2. import functools
  3. list1 = [1, 2, 3, 4, 5]
  4. def func(a, b):
  5. return a + b
  6. result = functools.reduce(func, list1)
  7. print(result) # 15

fifilter()

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

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

文件操作

⽂件操作的作⽤就是把⼀些内容(数据)存储存放起来,可以让程序下⼀次执⾏的时候直接使⽤,⽽不必重新制作⼀份,省时省⼒。

基础操作

  1. ## 在python,使⽤open函数,可以打开⼀个已经存在的⽂件
  2. open(name, mode)
  3. # w 和 a 模式:如果⽂件不存在则创建该⽂件;如果⽂件存在, w 模式先清空再写⼊, a 模式直接末尾追加。
  4. # 1. 打开⽂件
  5. f = open('test.txt', 'w')
  6. # 2.⽂件写⼊
  7. f.write('hello world')
  8. # 3. 关闭⽂件
  9. f.close()
  10. ## 读
  11. ## readlines()
  12. ## readlines可以按照⾏的⽅式把整个⽂件中的内容进⾏⼀次性读取,并且返回的是⼀个列表,其中每⼀⾏的数据为⼀个元素。
  13. f = open('test.txt')
  14. content = f.readlines()
  15. # ['hello world\n', 'abcdefg\n', 'aaa\n', 'bbb\n', 'ccc']
  16. print(content)
  17. # 关闭⽂件
  18. f.close()
  19. ## readline()
  20. ## readline()⼀次读取⼀⾏内容。
  21. f = open('test.txt')
  22. content = f.readline()
  23. print(f'第⼀⾏:{content}')
  24. content = f.readline()
  25. print(f'第⼆⾏:{content}')
  26. # 关闭⽂件
  27. f.close()

⽂件和⽂件夹的操作

  1. ## 导⼊os模块
  2. import os
  3. ## ⽂件重命名
  4. os.rename(⽬标⽂件名, 新⽂件名)
  5. ## 删除⽂件
  6. os.remove(⽬标⽂件名)
  7. ## 创建⽂件夹
  8. os.mkdir(⽂件夹名字)
  9. ## 删除⽂件夹
  10. os.rmdir(⽂件夹名字)
  11. ## 获取当前⽬录
  12. os.getcwd()
  13. ## 改变默认⽬录
  14. os.chdir(⽬录)
  15. ## 获取⽬录列表
  16. os.listdir(⽬录)
  1. import os
  2. # 设置重命名标识:如果为1则添加指定字符,flag取值为2则删除指定字符
  3. flag = 1
  4. # 获取指定⽬录
  5. dir_name = './'
  6. # 获取指定⽬录的⽂件列表
  7. file_list = os.listdir(dir_name)
  8. # print(file_list)
  9. # 遍历⽂件列表内的⽂件
  10. for name in file_list:
  11. # 添加指定字符
  12. if flag == 1:
  13. new_name = 'Python-' + name
  14. # 删除指定字符
  15. elif flag == 2:
  16. num = len('Python-')
  17. new_name = name[num:]
  18. # 打印新⽂件名,测试程序正确性
  19. print(new_name)
  20. # 重命名
  21. os.rename(dir_name+name, dir_name+new_name)

总结

  • ⽂件操作步骤
    • 打开
  1. ⽂件对象 = open(⽬标⽂件, 访问模式)
  • 操作
  1. ## 读
  2. ⽂件对象.read()
  3. ⽂件对象.readlines()
  4. ⽂件对象.readline()
  5. ## 写
  6. ⽂件对象.write()
  7. ##seek()
  • 主访问模式
    • w:写,⽂件不存在则新建该⽂件
    • r:读,⽂件不存在则报错
    • a:追加
  • ⽂件和⽂件夹操作
    • 重命名:os.rename()
    • 获取当前⽬录:os.getcwd()
    • 获取⽬录列表:os.listdir()