@

目录

前言

人生苦短，我用Python

 

Python基础（二）： https://blog.csdn.net/weixin_46818279/article/details/108855481

1. Python环境的搭建

解释器和开发集成环境pycharm的安装还是比较简单的。

1.1 python解释器的安装

（1） 到官网下载python解释器

下载地址：https://www.python.org/downloads/release/python-372/



注释： 这个解释器是3.7.2版本的

 

 

（2） 开始安装python解释器

安装解释器非常简单，一定要把把下面的环境变量打上对勾， 然后在上面选择Install Now。 这里我选择Install Now，默认安装在C盘。如下如所示



 

（3） 检验python解释器是否安装成功

在dos命令行下，输入python，如果出现版本号，则安装成功。

1.2 pycharm的安装

工欲善其事，必先利其器。Pycharm是一种Python IDE（集成开发环境），带有一整套可以帮助用户在使用Python语言时 提高其效率的工具。 简单的说提高你写代码的速度，编写代码更爽更舒服。

（1） 官网下载Pycharm

下载地址：http://www.jetbrains.com/pycharm/download/#section=windows

小提示： Pythoncharm分为专业版（professional）和社区版（community）。专业版集成了一些框架和库，收费的，基础里用不到，社区版就够用了。

 

 

（2） 开始安装pycharm

安装pycharm也非常简单，选好安装路径，我安装到D盘了。然后到达了如下图的界面，选择一个64位的桌面图标(shortcut)，再选择一个.py的联想，如下图所示。



（3） 在pycharm里新建一个项目

第一次在pycharm中新建项目的时候，你点New Project会到达如下图的界面。需要添加解释器，就是添加你安装解释器的路径，如下图所示：



 

小提示： python解释器添加完，项目创建好了之后，就可以愉快的写代码了。pycharm里面的快捷键，还有字体的修改，解释器的修改等等，可以百度自行搜索。

2. Python基础语法

2.1 基本语法

直接上代码，一看就懂了

  1. # 这是一个输出语句
  2. print("Hello,World")
  3. """
  4. 这是一个多行注释
  5. """
  7. '''
  8. 这也是一个多行注释
  9. '''
  10. ====================================================================================
  11. # 定义变量，储存数据TOM
  12. my_name = 'TOM'
  13. print(my_name)
  15. # 定义变量，储存数据，这是一瓶冰红茶
  16. icdTea = '这是一瓶冰红茶'
  17. print(icdTea)

2.2 数据类型

来一个思维导图，简单明了



直接上代码，一看就懂了

  1. # 整型和浮点型
  2. num1 = 1
  3. num2 = 1.2
  4. print(type(num1))
  5. print(type(num2))
  7. # 这是一个字符串类型
  8. a = 'hello,world!'
  9. print(type(a))
  11. # 这是一个布尔类型
  12. b = True
  13. print(type(b))
  15. # 这是一个列表类型
  16. c = [10,20,30]
  17. print(type(c))
  19. # 这是一个元组类型
  20. d = (10,20,30)
  21. print(type(d))
  23. # 这是一个集合
  24. e = {10,20,30}
  25. print(type(e))
  27. # 这是一个字典
  28. f = {'name': 'TOM','age': 18}
  29. print(type(f))

小提示：还有个复数类型，就是用于表示数学中的复数，用 real + imagej表示

2.3 标识符与关键字

这里不多说，跟C语言和Java中的知识都差不多一样，提几个需要注意的地方。

标识符：

（1）由数字、字母、下划线组成

（2）不能数字开头

（3）不能使用内置关键字

（4）严格区分大小写

2.4 格式化输出

直接上代码，一看就懂

  1. age = 18
  2. name = 'TOM'
  3. weight = 75.5
  4. stu_id = 1
  6. print('今年我的年龄是%d' % age)
  7. print('我的名字叫%s' % name)
  8. print('我的体重是%.3f' % weight)
  9. print('我的体重是%03d' % stu_id)  # 不够三位，用0补全
  11. print('我的名字叫：%s ，我的年龄是：%d' % (name,age))
  12. print("我的名字叫：%s，我的年龄是：%d" % (name,age+1))  # 年龄加一岁
  14. print("我的名字叫：%s，今年的年龄是：%d，我的体重是：%s，我的学号是：%03d" % (name,age,weight,stu_id))
  16. ===========================================================================================
  18. name = "TOM"
  19. age = 18
  20. weight = 75.5
  22. # %s比较强大
  23. print('我的名字叫：%s，我的年龄是：%s，我的体重是：%s' % (name,age,weight))
  25. ===========================================================================================
  27. name = 'TOM'
  28. age = 16
  30. # 语法：f'{表达式}'
  31. # 这样的输出格式更加高效和简洁
  33. print(f'我的名字叫{name},我的年龄为{age}')

小提示：

（1）务必掌握这种输出格式f'{表达式}' ，这种的输出格式更加高效简洁。f-格式化字符串是Python3.6中新增的格式化方法，这种方法更简单易读。

（2）常见的格式符号：%s （字符串） %d（有符号的十进制整数） %f（浮点数） %c（字符） 这几种是常见的格式符号，如果需要其他的再去查就好了。

2.5 转义字符和print的结束符

直接上代码，一看就懂

  1. print('hello world')
  2. print('hello\nworld')  # hello world直接换行输出
  3. print('\thello')    # 前面输出空格再输出hello
  5. =================================================================
  7. # 在python中，print()默认自带end='\n'这个换行结束符，用户可以按照需求更改结束符
  9. print('hello', end='\n')
  10. print('world')
  12. print('hello', end='\t')
  13. print('hello')
  15. print('hello', end='...')
  16. print('world')

小提示：要记住print的结束符这个小知识点。

2.6 输入与数据类型转换

直接上代码，一看就懂

  1. passward = input('请输入您的密码：')
  2. print(f'您输入的密码是：{passward}')
  4. # input接收到的数据类型都是字符串
  5. print(type(passward))
  7. ====================================================================================
  9. num = input("请输入一个数字：")
  10. print(num)
  11. print(type(num))
  13. # 强制转换为int类型
  14. print(type(int(num)))
  15. print(type(int(num)))
  17. ===================================================================================
  19. '''
  20. 因为得到数据类型并不是程序想要的数据类型，这个时候需要借助数据类型转换的函数来转换
  21. '''
  22. num = 1
  23. str1 = '10'
  25. # 1.将数据转换成浮点类型 float()
  26. print(type(float(num)))
  27. print(float(num))
  28. print(float(str1))
  30. # 2. 将数据转换成字符串型 str()
  31. print(type(str(num)))
  33. # 3. 序列转换成元组 tuple()
  34. list1 = [10,20]
  35. print(type(list1))
  36. print(type(tuple(list1)))
  37. print(tuple(list1))  	 # (100, 200)
  39. # 4. 将一个元组转换成序列 list()
  40. t1 = (100,200)
  41. print(list(t1)) 		# [100, 200]
  43. # 5. eval() 计算在字符串中的有效Python表达式，并返回一个表达式。把字符串中的数据转换成他原本的类型
  44. str3 = '1'
  45. str4 = '2.1'
  46. str5 = '(10,20)'
  47. str6 = '[10,20]'
  48. print(type(eval(str3)))   # <class 'int'>

2.7 复合赋值运算符和逻辑运算符

总结几个常用算数运算符

 

（1）**      返回a的b次幂，比如 2 ** 3,结果位8

（2）%      取余

（3）//      取整除，返回商的整数部分。

 

总结几个常用复合赋值运算符

 

直接上代码，一看就懂

  1. a = 10
  2. a += 1
  3. print(a)  # 11
  5. b = 10
  6. b *= 3
  7. print(b)  # 30
  9. # 注意：先算复合赋值运算符右侧的表达式，算复合赋值运算
  10. c = 10
  11. c += 1 + 2
  12. print(c)  # 13
  14. # 测试
  15. d = 10
  16. d *= 1 + 2
  17. print(d)  	# 30 说明先算复合赋值运算符右侧的表达式，再算复合赋值运算
  19. =====================================================================
  21. # 逻辑运算符的运用
  23. a = 0
  24. b = 1
  25. c = 2
  27. # 1.and
  28. print((a < b) and (a < c))   # True
  29. print(a > b and a < c)		# False
  31. # 2.or
  32. print(b > c or a < c)  # True
  34. # 3.not
  35. print(not a < b)	# False
  37. # 程序员的习惯
  38. # 加小括号为了避免歧义，增加优先级

3. Python常用语句

3.1 判断语句（if语句、if-else语句、if-elif语句）

直接上代码，一看就懂

  1. if True:
  2.     print('条件成立了')
  3. # 下面的代码没有缩进到if语句块，所以和if条件无关
  4. print('这个代码执行吗？')
  6. =================================================================
  8. age = 20
  9. if age >= 18:
  10.     print('已经成年可以上网')
  12. # 注意：不缩进的语句，跟if语句没有关系了。
  13. print('系统关闭')
  15. ================================================================
  17. # 注意：input接受用户输入的数据是字符串类型，这时需要转换为int类型才能进行判断
  18. age =int( input('请输入您的年龄：'))
  19. if age >= 18:
  20.     print(f'您输入的年龄是{age},已经成年可以上网')
  22. ================================================================
  24. age =int( input('请输入您的年龄：'))
  25. if age >= 18:
  26.     print(f'您输入的年龄是{age},已经成年可以上网')
  27. else:
  28.     print(f'你输入的年龄是{age}，小朋友，回家写作业去')
  30. ----------------------------------------------------------------
  32. age = int(input('请输入您的年龄'))
  33. if age < 18:
  34.     print(f'您输入的年龄是{age}，童工')
  35. elif (age >= 18) and (age <= 60):
  36.     print(f'您输入的年龄是{age}，合法')
  37. elif age > 60:
  38.     print(f'您输入的年龄是{age}，退休')
  40. -----------------------------------------------------------------
  42. age = int(input('请输入您的年龄'))
  43. if age < 18:
  44.     print(f'您输入的年龄是{age}，童工')
  45. #  条件的简化写法
  46. elif 18 <= age <= 60:
  47.     print(f'您输入的年龄是{age}，合法')
  48. elif age > 60:
  49.     print(f'您输入的年龄是{age}，退休')

3.2 判断语句（if嵌套）

直接上代码

  1. # if嵌套坐公交
  3. money = 1
  4. seat = 1
  6. if money == 1:
  7.     print('土豪，请上车')
  8.     # 判断是否能坐下
  9.     if seat == 1:
  10.         print('有空做，请坐下')
  11.     else:
  12.         print('没有空做，请等着....')
  13. else:
  14.     print('没钱，不让上车')

3.3 判断语句（if 综合案例）

直接上代码

  1. # 猜拳游戏
  2. import random
  4. player = int(input('请出拳：0--石头；1--剪刀；2--布'))
  5. # computer = 1
  6. computer = random.randint(0,2)
  7. if ((player == 0) and (computer == 1)) or ((player == 1) and (computer == 2)) or ((player == 2) and (computer == 0)):
  8.     print('玩家获胜，哈哈哈 ')
  9. elif player == computer:
  10.     print('平局')
  11. else:
  12.     print('电脑获胜')
  14. ================================================================================
  16. # 随机数的使用
  18. '''
  19. 步骤：
  20.     1.导入模块
  21.     import random
  22.     2.使用这个模块中的功能
  23.     random.randint
  24. '''
  25. import random
  26. num = random.randint(0,2)
  27. print(num)
  29. ================================================================================
  31. # 三目运算符
  32. a = 1
  33. b = 2
  34. c = a if a > b else b
  35. print(c)
  37. aa = 10
  38. bb = 6
  39. cc = aa - bb if aa > bb else bb - aa
  40. print(cc)

3.4 循环语句（while循环）

直接看个栗子就能上手使用while循环

  1. # 1-100 累加和
  2. i = 1
  3. result = 0
  4. while i <= 100:
  5.     result += i
  6.     i += 1
  8. print(result)

3.5 循环语句（while循环嵌套）


  2. # 重复打印5行星星
  4. j = 0
  5. while j < 5:
  6.     # 一行星星的打印
  7.     i = 0
  8.     while i < 5:
  9.         # 一行内的星星不能换行，取消print默认结束符\n
  10.         print('*', end='')
  11.         i += 1
  12.     # 利用空的print来进行换行
  13.     print()
  14.     j += 1
  16. ============================================================
  18. # 打印三角形，每行星星的个数和行号数相等
  19. # j表示行号
  20. j = 0
  21. while j < 5:
  22.     # 一行星星的打印
  23.     i = 0
  24.     while i <= j:
  25.         # i表示每行里面星星的个数，这个数字要和行号相等所以i要和j联动
  26.         print('*', end='')
  27.         i += 1
  28.     # 利用空的print来进行换行
  29.     print()
  30.     j += 1
  32. =============================================================
  34. j = 1
  35. while j <= 9:
  36.     # 一行表达式的开始
  37.     i = 1
  38.     while i <= j:
  39.         print(f'{i} * {j} = {i*j} ' , end='\t')
  40.         i += 1
  41.     # 一行表达式的结束
  42.     print()  # 自带换行符
  43.     j += 1

3.6 循环语句（while...else）


  2. '''
  3. 所谓else指的是循环正常结束之后要执行的代码，
  4. 即如果是break终止循环的情况，else下方缩进的代码将不执行。
  5. '''
  7. i = 1
  8. while i <= 5:
  9.     if i == 3:
  10.         break
  11.     print('媳妇我错了')
  12.     i += 1
  13. else:
  14.     print('媳妇原谅我了，真开心呐')
  16. ===================================================================
  18. """
  19. 因为continue是退出了当前一次循环，继续下一次循环，所以改循环在continue控制下
  20. 是可以正常结束的，当循环结束后，则执行了else缩进的代码。
  21. """
  22. i = 1
  23. while i <= 5:
  24.     if i == 3:
  25.         # 切记在执行continue之前，一定要改变计数器。否则就会陷入死循环
  26.         i += 1
  27.         continue
  28.     print('媳妇我错了')
  29.     i += 1
  30. else:
  31.     print('媳妇原谅我了，真开心呐')

3.7 循环语句（for、for...else）


  2. str1 = 'ilovepython'
  3. for i in str1:
  4.     # 当某些条件成立，退出循环  条件：i取到字符e的时候退出循环
  5.     if i == 'e':
  6.         # continue
  7.         break
  8.     print(i)
  10. ======================================================================
  12. 所谓else指的是循环正常结束之后要执行的代码，
  13. str1 = 'ilovepython'
  14. for i in str1:
  15.     print(i)
  16. else:
  17.     print('循环正常结束执行的else代码')

4. 字符串

4.1 字符串的使用

  1. # 字符串的使用区别
  3. a = 'hello' \
  4.     ' world'
  5. print(a)   # 输出一行 hello world
  7. c = '''hello
  8. world'''
  9. print(type(c))
  10. print(c)       # 换行输出hello world
  12. d = """hello
  13. world"""
  14. print(type(d))  # <class 'str'>
  15. print(d)        # 会直接换行输出
  17. # 打印 I'm Tom，使用单引号，必须使用转移字符，把他转义过去
  18. e = 'I\'m Tom'
  19. print(e)
  21. # 要是有单引号出现可以使用双引号括住
  22. f = "I' love Tom"
  23. print(f)
  25. ============================================================================
  27. # 字符串的输出 
  29. name = 'Tom'
  30. print('我的名字是%s' % name)
  31. print(f'我的名字是{name}')
  33. ==============================================================================
  35. # 字符串的输入
  36. password = input('请输入您的密码')
  37. print(f'您输入的密码是{password}')
  38. # input接收到的用户输入的数据都是字符串
  39. print(type(password))

4.2 下标和切片

（1）下标

  1. str1 = 'abcdefg'
  2. print(str1)
  3. # 数据在运行过程中存储在内存
  4. # 使用字符串中特定的数据
  5. # 使用编号精确找到某个字符数据，下标索引值
  6. # str[下标]
  7. print(str1[0])  # 输出a
  8. print(str1[1])  # 输出b

（2）切片

  1. # 序列名[开始位置的下标：结束位置的下表：步长]
  2. # 取值区间左闭右开的
  4. str1 = '012345678'
  5. # print(str1[2:5:1]) 234
  6. # print(str1[2:5:2]) 24
  7. # print(str1[2:5]) 234  # 如果不写步长，默认步长是1
  8. # print(str1[:5]) 01234   # 如果不写开始，默认从0开始选取
  9. # print(str1[2:]) 2345678 # 如果不写结束，表示选取到最后
  10. # print(str1[:]) 012345678  # 如果不写开始和结束，表示选取所有
  12. # 负数测试
  13. # print(str1[::-1]) 876543210 # 如果步长为负数，表示倒叙选取
  14. # print(str1[-4:-1])  567    下标为-1表示最后一个数据，依次向前类推
  16. # 终极测试
  17. # print(str1[-4:-1:1]) 567
  18. print(str1[-4:-1:-1]) # 不能选取出数据：从-4开始到-1结束，选取方向从左到右，但是-1步长：从右向左选取
  19. # 如果选取方向（下标开始到结束的方向）和步长方向冲突，则无法选取数据
  20. print(str1[-1:-4:-1]) # 876 方向一致就可以正确输出

小总结： 下标是精确的找到某一个元素，切片可以利用下标找到某一部分元素（左闭右开）

4.3 字符串常用操作方法（查找、修改、判断）

（1）查找

  1. mystr = 'hello world and itcast and itsmail and Python'
  3. # 1. find()
  4. print(mystr.find('and')) # 输出的是12，以为下标是从0开始数的
  5. print(mystr.fing('and',15,30))
  6. print(mystr.find('ands')) # -1,ands字串不存在
  8. # 2. index
  9. print(mystr.find('and')) # 12
  10. print(mystr.find('and',15,30)) #23
  11. print(mystr.index('ands')) #如果index查找字串不存在，报错
  13. # 3. count()
  14. print(mystr.count('and')) 3
  15. print(mystr.count('and',15,30)) 1
  16. print(mystr.count('ands')) 0
  18. # 4. rfind()
  19. print(mystr.rfind('and')) 35
  20. print(mystr.find('ands')) -1 如果没找到，则返回-1
  22. # 5. rindex()
  23. print(mystr.rindex('and')) 35  就算是到着找，它的下标还是从左到右从下标0开始的
  24. print(mystr.rindex('ands'))

（2）修改

  1. # 遇到列表、字典，内部的数据可以直接修改，修改的就是原列表或者原字典。叫做可变类型。
  2. # 字符串是一个不可变类型的数据
  4. mystr = 'hello world and itcast and itheima and Python'
  5. # replace() 把and换成he replace函数有返回值，返回值是修改后的字符串
  6. new_str = mystr.replace('and','he')
  7. # new_str = mystr.replace('and','he',1)
  8. # 替换次数如果超出字串出席那的次数，表示替换所有这个字串
  9. # new_str = mystr.replace('and','he',10)
  10. print(mystr)
  11. print(new_str)
  13. # 调用了replace函数后，发现原有字符串的数据并没有做到修改，修改后的数据是replace函数的返回值
  14. # 说明字符串是不可变数据类型
  15. # 数据是否可以改变划分为 可变类型，不可变类型
  17. # 2. split()  分割，返回一个列表，丢失分割字符
  18. list1 = mystr.split('and')
  19. print(list1)
  21. # 3. join() 合并列表里面的字符串数据为一个大字符串
  22. mylist = ['aa','bb','cc']
  23. new_str = '...'.join(mylist)
  24. print(new_str)

修改-非重点

  1. # 一、字符串对齐
  2. # mystr.ljust(10) 左对齐
  3. # mystr.rjust(10) 右对齐
  4. # mystr.rjust(10,'.') 以点作为填充效果
  5. # mystr.center(10) 中间居中
  6. # mystr.center(10,'.') 以点填充空白的地方
  8. # 二、大小写转换
  9. mystr = 'hello world and itcast and itheima and Python'
  10. # 1. capitalize() 字符串首字母大写
  11. # new_str = mystr.capitalize()
  12. # print(new_str)
  14. # 2. title():字符串中每个单词首字母大写
  15. # new_str = mystr.title()
  16. # print(new_str)
  18. # 3. upper():小写转大写
  19. # new_str = mystr.upper()
  20. # print(new_str)
  22. # 4. lower()：大写转小写
  23. # new_str = mystr.lower()
  24. # print(new_str)
  26. # 三、删除空白字符
  27. str1 = "      hello world and itcast and itheima and Python  "
  28. # 1. lstrip():删除字符串左侧空白字符
  29. # print(str1)
  30. # new_str = str1.lstrip()
  31. # print(new_str)
  33. # 2. rstrip():删除字符串右侧空白字符
  34. new_str = str1.rstrip()
  35. print(str1)
  36. print(new_str)
  38. # 3. strip():删除字符串两侧空白字符
  39. # new_str = str1.strip()
  40. # print(new_str)

（3）判断

  1. # 判断开头或结尾
  2. mystr = 'hello world and itcast and itheima and Python'
  3. # 1. startswith(字串，开始位置下标，结束位置下标):判断字符串是否以某个字串开头
  4. print(mystr.startswith('hello'))
  5. print(mystr.startswith('hel'))
  6. print(mystr.startswith('hels'))
  7. print(mystr.startswith('hell',0,10)) 开始位置下标和结束位置下标可以省略
  9. # 2. endswich(字串，开始位置下标，结束位置下标)，始位置下标和结束位置下标可以省略
  10. print(mystr.endswith('Python'))
  11. print(mystr.endswith('Pythons'))
  13. # 判断
  14. 3. isalpha():字母  纯字母才可以，如果中间有空格返回的false
  15. print(mystr.isalpha())
  17. # 4. isdigit():数字，中间也不能有空格，否则返回false
  18. print(mystr.isdigit())
  19. mystr1 = "12345"
  20. print(mystr1.isdigit())
  22. # 5. isalnum():数字或字母或组合
  23. print(mystr1.isalnum()) # True
  24. print(mystr.isalnum())  # False 因为中间有空格
  25. mystr2 = 'abc123'
  26. print(mystr2.isalnum())
  28. # 6. isspace():判断是否是空白，是返回True
  29. print(mystr.isspace())  # False
  30. mystr3 = ' '
  31. print(mystr3.isspace())	 # True

5. 列表、元组

5.1 列表的创建和使用

  1. name_list = ['TOM','Lily','ROSE']
  2. print(name_list)   # ['TOM', 'Lily', 'ROSE']
  3. # 根据下标进行输出
  4. print(name_list[0])  # 输出 TOM
  5. print(name_list[1])  # 输出 Lily
  6. print(name_list[2])  # 输出 ROSE

5.2 判断数据是否在列表中存在

  1. name_list = ['TOM','Lily','ROSE']
  2. # 1. in  如果在里面就返回true，否则false
  3. print('TOM' in name_list)
  4. print('TOMS' in name_list)
  6. # 2. not in   这个跟in相反
  7. print('TOM' not in name_list)
  8. print('TOMS' not in name_list)

体验案例

  1. name_list = ['TOM','List','ROSE']
  3. # 需求：注册邮箱，用户输入一个账户名，判断这个账号是否存在，如果存在，提示用户，否则提示可以注册
  4. name = input("请输入您的邮箱账号名：")
  5. if name in name_list:
  6.     # 提示用户名已经存在
  7.     print(f'您输入的名字是{name}，此用户已经存在')
  8. else:
  9.     # 提示可以注册
  10.     print(f'您输入的名字是{name},可以注册')

5.3 列表的常见操作（查找、增加、删除、修改、赋值）

（1）查找（index、count、len）

  1. name_list = ['TOM','Lily','Rose']
  3. # 1.index()
  4. print(name_list.index('TOM'))  #返回 0
  5. # print(name_list.index('TOMs'))  没有找到，报错
  7. # 2. count()
  8. print(name_list.count('TOM'))
  9. # print(name_list.count('TOMS')) # 报错
  11. # 3.len()
  12. print(len(name_list)) # 输出3

（2）增加（append、extend、insert）

  1. # 1. 列表数据是可变的  -- 列表是可变类型
  2. # 2. append函数追加数据的时候如果是一个序列，追加整个序列到列表的结尾
  4. name_list = ['TOM','Lily','ROSE']
  5. name_list.append('xiaoming')
  6. name_list.append([11,22])
  7. name_list.append(11)
  8. print(name_list)  # 输出结果为：['TOM', 'Lily', 'ROSE', 'xiaoming', [11, 22], 11]
  1. # extent() 追加数据是一个序列，把数据序列里面的数据拆开然后逐一追加到列表的结尾
  2. name_list = ['TOM','Lily','ROSE']
  3. name_list.extend('xiaoming')
  4. # 把序列拆开，逐一的放到列表中
  5. name_list.extend(['xiaoming','xiaojun'])
  6. print(name_list)
  7.  # 输出结果为：['TOM', 'Lily', 'ROSE', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g', 'xiaoming', 'xiaojun']
  1. name_list = ['Tom','Lily','ROSE']
  2. # name_list.insert(下标，数据)  在指定位置加入数据
  3. name_list.insert(1,'aa')
  4. print(name_list) # 输出的结果为：['Tom', 'aa', 'Lily', 'ROSE']

（3）删除（del、pop、remove、clear）

  1. name_list = ['Tom','Lily','ROSE']
  3. # 1. del
  4. # del name_list
  5. # print(name_list) 已经把列表已经删除，已经没有列表了
  7. # del 也可以指定下标的数据
  8. # del name_list[0]
  9. # print(name_list)   # 输出的结果 ['Lily', 'ROSE']
  11. # 2. pop() 删除指定下标的数据，如果不指定下标，默认删除最后一个数据
  12. # 无论是按照下标还是删除最后一个，pop函数都会返回这个被删除的数据. 比较厉害的是删除一个数据能用一个变量去接收
  13. del_name = name_list.pop()
  14. del_name = name_list.pop(1)
  15. print(del_name)
  16. print(name_list)
  18. # 3. remove(数据) 按照指定的数据进行删除的
  19. # name_list.remove('ROSE')
  20. # print(name_list)
  22. # 4. clear() -- 清空
  23. # name_list.clear()
  24. # print(name_list)  # 直接清空整个数据

（4）修改（reverse、sort）

  1. name_list = ['TOM','Lily','ROSE']
  3. # 修改指定下标的数据
  4. # name_list[0] = 'aaa'
  5. # print(name_list) # ['aaa', 'Lily', 'ROSE']
  7. # 2. 逆序 reverse()
  8. list1 = [1, 3, 4, 2, 5]
  9. # list1.reverse()
  10. # print(list1)
  12. # 3. sort() 排序：升序（默认）和 降序
  13. # list1.sort()  # 升序
  14. list1.sort(reverse=False)  # 升序 [1, 2, 3, 4, 5]
  15. list1.sort(reverse=True)   # 降序 [5, 4, 3, 2, 1]
  16. print(list1)

（5）赋值

  1. name_list = ['tom','lucy','jack']
  2. list1 = name_list.copy()
  3. print(list1)
  4. print(name_list)

5.4 列表的循环遍历（for、while）

for循环

  1. name_list = ['tom','rose','jack']
  2. i = 0
  3. while i < len(name_list):
  4.     print(name_list[i])
  5.     i += 1

while循环

  1. # for循环的代码量要少于while的代码量
  2. # 一般在工作岗位下，涉及到遍历序列当中的数据的话，一般优选于for循环
  3. name_list = ['tom','rose','jack']
  4. for i in name_list:
  5.     # 遍历序列中的数据
  6.     print(i)

5.5 列表的嵌套

列表嵌套时的数据查询

  1. name_list = [['TOM', 'Lily','Rose'], ['张三','李四','王二'], [ '小红', '小绿', '小蓝']]
  2. # print(name_list)
  3. # 列表嵌套的时候的数据查询
  4. print(name_list[0])
  5. print(name_list[0][0])

案例-随机分配办公室

  1. # 需求：八位老师，3个办公室，将8为老师随机分配到3个办公室
  2. '''
  3. 步骤：：
  4. 1.准备数据
  5.     1.1 8位老师 -- 列表
  6.     1.2 3个办公室 -- 列表嵌套
  7. 2. 分配老师到办公室
  8.     随机分配
  9.     就是把老师的名字写入到办公室列表 --办公室列表追加老师数据
  10. 3. 验证是否分配成功
  11.     打印办公室详细信息: 每个办公室的人数和对应的老师名字
  13. '''
  14. import random # 随机模块
  15. # 1. 准备数据
  16. teachers = ['A','B','C','D','E','F','G','H']  # 列表存数据
  17. offices = [[], [], []]      # 嵌套列表
  19. # 2. 分配老师到办公室 -- 取到每个老师放到办公室列表 -- 遍历老师列表数据
  20. for name in teachers:
  21.     # 列表追加数据  -- append(整体添加) --extend(拆开添加) --insert(在指定位置加入数据)
  22.     num = random.randint(0,2)
  23.     offices[num].append(name)           #追加数据
  24. # print(num)
  25. # print(offices)
  27. # 为了更贴合生活，把各个办公室子列表加一个办公室编号1 ，2 ，3
  28. i = 1
  29. # 3. 验证是否成功
  30. for office in offices:
  31.     # 打印办公室人数 -- 子列表数据的个数 len()
  32.     print(f'办公室{i}的人数是{len(office)}')
  33.     # 打印老师的名字
  34.     # print() -- 每个自立表里面的名字个数不一定 -- 遍历 -- 子列表
  35.     for name in office:
  36.         print(name)
  37.     i += 1

5.6 元组的访问

注意： 如果是单个数据的元组，那么后面必须加逗号，否则就不是元组的数据类型，而是整个数据本身的数据类型

  1. # 输出元组
  2. t1 = (10, 20, 30)
  3. print(t1)  # 输出 (10, 20, 30)
  5. # 如果是单个数据的元组，那么后面必须加逗号，否则就不是元组的数据类型，而是整个数据本身的数据类型
  6. # 1.多个数据元组
  7. t1 = (10, 20, 30)
  8. print(type(t1))  # 输出 <class 'tuple'>
  10. # 2. 单个数据元组
  11. t2 = (10,)
  12. print(type(t2))  # 输出 <class 'tuple'>
  13. =====================================================================
  15. # 3. 如果单个数据的元组不加逗号
  16. t3 = (10)
  17. print(type(t3))  # 输出 <class 'int'>
  19. t4 = ('aaa')
  20. print(type(t4))  # 输出 <class 'str'>
  21. ================================================================================
  22. t5 = ('aaa',)
  23. print(type(t5))  # 输出  <class 'tuple'>

5.7 元组常见操作（查找、修改）

（1）查找

  1. t1 = ('aa', 'bb', 'cc')
  3. # 1. 下标
  4. print(t1[0])   # aa
  6. # 2. index()
  7. print(t1.index('aa'))  # 输出0  其实有参数二，有参数三对应一个查找的范围,如果没有找到就直接报错。
  9. # 3. count()
  10. print(t1.count('aa')) # 统计aa的次数，输出结果为1
  12. # 4. len()
  13. print(len(t1))  # 统计整个元组的个数，输出结果为3

（2）修改

  1. # 元组确实不能修改，但是元组中含有的列表可以修改。
  2. # 工作中尽可能遵循一个规则，但凡是出现在小括号元组里面的数据，尽可以能靠自觉去要求不做修改
  3. # 工作中如果是同事的代码，有数据出现在元组中，尽可能在查找操作的时候，小心一点，尽可能不要去修改这一部分的操作。
  5. t1 = ('aa', 'bb', 'cc')
  6. # t1[0] = 'aaa' 这个操作是错的，是不能修改的。
  7. t2 = ('aa', 'bb', ['cc', 'dd'])
  8. print(t2[2])
  9. t2[2][0] = 'TOM'
  10. print(t2)

6. 字典、集合

6.1 字典的创建

直接上栗子，一看就懂

  1. '''
  2. 字典里面的数据是以键值对形式出现，字典数据和数据顺序没有关系，
  3. 即字典不支持下标,后期无论数据如何变化，只需要按照对应的键的名字来查找数据即可
  4. '''
  6. # 字典特点： 1. 符号为大括号 2. 数据为键值对形式出现  3. 各个键值对之间用逗号隔开
  7. # 符合上面三个条件就是字典，字典不支持下标。
  8. # {} 里面放入键值对，用逗号隔开
  10. # 创建有数据的字典
  11. dict1 = {'name' : 'tom', 'age' : 18, 'gender': '男'}
  12. # 查看一下dict1的数据类型
  13. print(type(dict1))   # <class 'dict'>
  15. # 创建空字典
  16. dict2 = {}
  17. print(type(dict2))  # <class 'dict'>
  19. # 用dict()函数来创建空字典
  20. dict3 = dict()
  21. print(type(dict3))
  22. print(dict3)  # 输出 {}

6.2 字典常用操作（增、删、改、查）

新增数据

  1. '''
  2. 新增数据的写法：字典序列[key] = 值
  3.  这里的字典为可变类型，打印原字典名，就能看到修改新增之后的数据。之前的元组是不可变类型，是不能修改内部数据的。
  4. 注意: 如果key存在则修改这个key对应的值；如果key不存在则新增此键值对
  5. '''
  7. dict1 = {'name': 'TOM' , 'age':20 , 'gender': '男' }
  9. # name这个键存在这个字典中，所以修改键值对
  10. dict1['name'] = 'ROSE'
  11. print(dict1)  # 输出修改后的字典 {'name': 'ROSE', 'age': 20, 'gender': '男'}
  13. # id这个key不存在这个字典中，所以新增此键值对
  14. dict1['id'] = 110
  15. print(dict1)   # 输出新增后的字典{'name': 'TOM', 'age': 20, 'gender': '男', 'id': 110}

删除数据

  1. dict1 = {'name': 'TOM', 'age': 20 , 'gender': '男'}
  3. # 1.del 删除字典或指定的键值对
  5. # 删除字典
  6. # del(dict1)
  7. # print(dict1)   # 报错，说明已经删除了
  9. # 删除指定的字符串
  10. # del dict1['name']  # 删除key为name的键值对
  11. # del dict1['names']  # 如果删除的内容不存在就会报错
  12. # print(dict1)		# {'age': 20, 'gender': '男'}
  14. # 2. clear() 清空字典
  15. dict1.clear()
  16. print(dict1)      # 输出{}

修改数据

  1. dict1 = {'name':'tom', 'age':20 , 'gender':'男'}
  3. # dict1['name'] = 'lily'
  4. # print(dict1)     # {'name': 'lily', 'age': 20, 'gender': '男'}
  6. dict1['id'] = 2020
  7. print(dict1)    # {'name': 'tom', 'age': 20, 'gender': '男', 'id': 2020}

查找数据

  1. # 可迭代的对象指代的是可以用for遍历的对象
  3. dict1 = {'name':'tom', 'age': 20 , 'gender':'男'}
  5. # 1. [key]
  6. # print(dict1['name'])    #  输出tom
  7. # print(dict1['names'])   # 如果查找的值是不存在的key，则会报错
  9. # 2.函数
  11. # 2.1 get()
  12. # 语法： 字典序列.get(key,默认值)
  14. # print(dict1.get('name'))   # tom
  15. # print(dict1.get('names'))  # 如果键值不存在，返回None
  16. # print(dict1.get('names','不存在')) # 如果键值不存在，返回“不存在”
  18. # 2.2 keys() 查找字典中所有的key，返回可迭代对象
  19. print(dict1.keys())  # 输出 dict_keys(['name', 'age', 'gender'])
  21. # 2.3 value() 查找字典中所有的value，返回可迭代对象
  22. print(dict1.values())  # 输出 dict_values(['tom', 20, '男'])
  24. # 2.4 items() 查找字典中所有的键值对，返回可迭代对象，里面的数据是元组，元组数据1是字典的key，元组数据2是字典key对应的值
  25. print(dict1.items())  # 输出dict_items([('name', 'tom'), ('age', 20), ('gender', '男')])

6.3 字典的遍历

  1. # key遍历
  3. dict1 = {'name':'tom', 'age':20 , 'gender': '男'}
  5. for key in dict1.keys():
  6.     print(key)
  7. '''
  8. 输出结果：
  9.        name
  10.        age
  11.        gender
  12. '''    
  14. ==================================================================
  16. # value遍历
  18. dict1 = {'name':'tom', 'age':20, 'gender':'男'}
  20. for value in dict1.values():
  21.     print(value)
  23. '''
  24. 输出结果：
  25. 		tom
  26. 		20
  27. 		男
  28. '''
  29. =====================================================================
  31. # 键值对遍历
  32. # dict1.items 可迭代对象的内部是元组
  33. dict1 = {'name':'tom', 'age': 20 , 'gender': '男'}
  34. for item in dict1.items():
  35.     print(item)
  36. '''
  37. 输出结果：
  38.         ('name', 'tom')
  39.         ('age', 20)
  40.         ('gender', '男')
  41. '''
  43. =====================================================================
  45. # 键值对拆包遍历
  47. dict1 = {'name':'tom', 'age':'20', 'gender':'男'}
  49. # xx.items():返回可迭代对象，内部是元组，元组有2个数据
  50. # 元组数据1是字典的key，元组数据2是字典的value
  52. for key,value in dict1.items():
  53.     # print(key)
  54.     # print(value)
  55.     print(f'{key}={value}')
  57. '''
  58. 输出的内容是：
  60.     	name=tom
  61.    		age=20
  62.     	gender=男
  63. '''

6.4 字典小总结

  1. 定义字典
  2. dict1 = {'name':'TOM', 'age':30}
  3. dict2 = {}
  4. dict3 = dict()
  6. 常见操作
  7.     增/改
  8. 字典序列[key] = 值
  10. 查找
  11.     字典序列[key]
  12.     keys()
  13.     values()
  14.     items()

6.5 集合的创建

直接上栗子：

  1. '''
  2. 1 .集合有一个特点：去重，也就是说集合当中的数据是没有重复的，如果有不允许重复的数据出现的时候，这是用用集合存储数据即可。
  3. 2. 创建集合使用{} 或 set()；但是如果要创建空集合只能使用set()，因为 {} 用来创建空字典的
  4. 3. 数据的展示循序跟写代码的顺序不一样，集合没有顺序，因为没有顺序，所以不支持下标的操作。
  5. '''
  7. # 1. 创建有数据的集合
  8. s1 = {10,20,30,40,50}
  9. print(s1)
  11. s2 = {10,20,30,20,30}
  12. print(s2)     #{10, 20, 30} 输出结果 因为有去重功能
  14. s3 = set('姓名')
  15. print(s3)     # {'姓', '名'}
  17. # 2.创建新集合
  18. s4 = set()
  19. print(s4)		# set()
  20. print(type(s4))   # <class 'set'>
  22. # 这里不能用{}来创建新集合
  23. s5 = {}
  24. print(type(s5)) # 输出的结果是<class 'dict'> ，因为这时字典的创建方式

6.6 集合常见操作（增、删、查）

增加数据

  1. s1 = {10,20}
  2. # 1. 集合是可变类型
  3. # add() 用来增加一个单一数据到原集合当中来
  4. s1.add(100)
  5. print(s1)      # {100, 10, 20}
  7. # 集合有去重功能，如果追加的数据是集合已有数据，则什么事情都不做
  8. s1.add(100)
  9. print(s1)
  11. # update() 用来增加一个数据序列到原集合当中来
  12. s1.update([10,20,30,40,50])
  13. print(s1)  # 输出 {100, 40, 10, 50, 20, 30} 有去重功能，如果添加的数据原集合中有的，则不进行操作。
  15. # s1.update(299) 不能直接添加单一数据
  16. s1.update([299]) # 这种方式的添加就可以
  17. print(s1)

删除数据

  1. s1 = {10,20,30}
  2. s2 = {10,20,30}
  3. s3 = {10,20,30}
  4. # 1. remove():删除指定数据，如果数据不存在则报错
  5. s1.remove(10)
  6. print(s1)  # {20, 30}
  8. # s1.remove(333)
  9. # print(s1)  # 报错，以为删除的没有这个数据
  11. ============================================================================
  13. # 2. discard():删除指定数据，如果数据不存在不报错
  14. s2.discard(10)
  15. print(s2)  # 输出 {20, 30}
  17. s2.discard(666)  # 就算删除的数据不存在也不会报错
  19. ============================================================================
  21. # 3. pop():随机删除某个数据，并返回这个数据
  22. del_num = s3.pop()
  23. print(del_num) 		 # 10
  24. print(s1)		# {20, 30}

查找数据


  2. s1 = {10,20,30,40}
  4. # 用in和not in 判断数据10是否在集合中存在
  6. print(10 in s1)  # Ture
  7. print(10 not in s1)  # False

6.7 集合小总结

  1. '''
  2. 创建结合
  3.     有数据集合
  4.         s1 = {数据1，数据2，...}
  5.     无数据集合
  6.         s1 = set()
  8. 常见操作
  9.     增加数据
  10.         add()
  11.         update()
  12.     删除数据
  13.         remove()
  14.         discard()
  15. '''

最后，欢迎关注公众号【C you again】，获取更多IT技术文章、Java开发面试题、计算机类毕业设计等等。。。。



原文链接：https://blog.csdn.net/weixin_46818279/article/details/108576298

【详细】Python基础（一）的更多相关文章

  1. 【Python基础】*args，**args的详细用法

     Python基础知识:*args,**args的详细用法 参考:https://blog.csdn.net/qq_29287973/article/details/78040291 *args 不定 ...

  2. Python之路3【第一篇】Python基础

    本节内容 Python简介 Python安装 第一个Python程序 编程语言的分类 Python简介 1.Python的由来 python的创始人为吉多·范罗苏姆(Guido van Rossum) ...

  3. 比较详细Python正则表达式操作指南(re使用)

    比较详细Python正则表达式操作指南(re使用) Python 自1.5版本起增加了re 模块,它提供 Perl 风格的正则表达式模式.Python 1.5之前版本则是通过 regex 模块提供 E ...

  4. python基础——面向对象编程

    python基础——面向对象编程 面向对象编程——Object Oriented Programming,简称OOP,是一种程序设计思想.OOP把对象作为程序的基本单元,一个对象包含了数据和操作数据的 ...

  5. 【Python全栈笔记】00 12-14 Oct Linux 和 Python 基础

    Linux 基础认识 更加稳定,安全,开源 设置好ssh协议后可以通过windows系统连接Linux,基于ssh协议进行通信 '/' 为根目录 cd / -> 切换到根目录 ls -lh 列出 ...

  6. Python基础教程【读书笔记】 - 2016/7/10

    希望通过博客园持续的更新,分享和记录Python基础知识到高级应用的点点滴滴! 第五波:第1章  基础知识 [总览]  介绍如何得到所需的软件,然后讲一点点算法及其主要的组成.学习变量variable ...

  7. python基础教程笔记—即时标记（详解）

    最近一直在学习python,语法部分差不多看完了,想写一写python基础教程后面的第一个项目.因为我在网上看到的别人的博客讲解都并不是特别详细,仅仅是贴一下代码,书上内容照搬一下,对于当时刚学习py ...

  8. 第一篇:python基础

    python基础   python基础 本节内容 python起源 python的发展史 为什么选择python3 第一个python程序 变量定义 表达式和运算符 用户输入 流程控制 判断 流程控制 ...

  9. Python之路,Day4 - Python基础4 (new版)

    Python之路,Day4 - Python基础4 (new版)   本节内容 迭代器&生成器 装饰器 Json & pickle 数据序列化 软件目录结构规范 作业:ATM项目开发 ...

随机推荐

  1. Spark流式状态管理（updateStateByKey、mapWithState等）

    通常使用Spark的流式框架如Spark Streaming,做无状态的流式计算是非常方便的,仅需处理每个批次时间间隔内的数据即可,不需要关注之前的数据,这是建立在业务需求对批次之间的数据没有联系的基 ...

  2. 【ZJOI2019】线段树（线段树 & dp）

    Link UOJ LOJ Luogu Solution 很玄妙的一道题,考察了对线段树较本质的理解 然而我并不会这个所谓最可做的题 首先,虽然题目很复杂,好像每个点的标记变化都很玄学,但是我们可以深入 ...

  3. postgresql 运行sql文件

    方法一: [postgres@node01 ~]$ psql -Upostgres postgres=# \l List of databases Name | Owner | Encoding | ...

  4. 【面试专栏】Java并发编程：volatile关键字

    1.  内存模型 若一个变量在多线程环境下同时操作,则可能出现结果不一致的情况.这就是常说的缓存不一致性问题. 解决缓存不一致问题,通常有两个解决方案: 通过在总线加LOCK#锁的方式 因为CPU和其 ...

  5. torch中squeeze与unsqueeze用法

    import torch torch中的squeeze与unsqueeze作用是去除/添加维度为1的行 例如,a=torch.randn(2,3) 那么b=a.unsqueeze(0),b为(1,2, ...

  6. [OI笔记]NOIP2017前（退役前）模拟赛的总结

    好久没写blog了- 在noip2017前的最后几天,也就是在我可能将要AFO的前几天写点东西吧- 记录这最后几个月打的那些大大小小的模拟赛 一些比赛由于不允许公开所以就没有贴链接跟题面了- 2017 ...

  7. phpMyadmin(CVE-2018-12613)后台任意文件包含漏洞分析

    前言 影响版本:4.8.0--4.8.1 本次复现使用4.8.1     点击下载 复现平台为vulhub.此漏洞复现平台如何安装使用不在赘述.请自行百度. 漏洞复现 漏洞环境启动成功. 访问该漏洞地 ...

  8. 01 . GitLab简介及环境部署

    GitLab简介 最初,该产品名为GitLab,是完全免费的开源软件,按照MIT许可证分发. 2013年7月,产品被拆分为:GitLabCE(社区版)和GitLabEE(企业版),当时,GitLabC ...

  9. Listary效率快捷键

    快捷键 打开搜索框快捷键: 双击Ctrl键 上一个项目:向上键 下一个项目:向下键/Tap 打开动作:Enter 属性窗口:Ctrl+O (查询)关键字 作用范围:搜索框 使用方法:命令+空格+关键字 ...

  10. Selenium多浏览器测试

    在浏览器的兼容性测试中,会测试产品在不同浏览器上的兼容性,比较主流的浏览器有IE.Firefox.Chrome,Opera,Safari等.还有其它如360.QQ.遨游.百度等浏览器都是基于IE或者c ...