Python基础【1】

Python基础 第一站 出使Python国 1. Python的自述

• Python学习
  

• 背后有最强大的代码库

• 被称为”胶水语言“

• 学习方向

2. Python简介

• 1989年，荷兰人吉多·范罗苏姆开始创造，在1991年真正问世，被起名Python大蟒蛇
• 特点
  • 跨平台的计算机程序设计语言
  • 一种解释性语言，在开发过程中没有编译的环节
  • 一种交互式语言，在提示符>>>后直接执行代码
  • 面向对象语言，一切皆对象
  • 简单易学，适用范围广

3. 搭建Python开发环境

• 官网下载安装包进行安装

4. PyCharm安装

• .py开头模板设置：

5. 输出函数print

• 可以输出的内容

  • 数字

  • print(520)
    

  • 字符串

  • print('helloworld')
    

  • 含有运算符的表达式

  • print(3+1)
    

• 输出的目的地

  • 显示器

  • 将数据输出到指定文件中，注意点：1.所指定的盘符必须存在，2.使用file=fp

    fp=open('D:/text.txt','a+')
    print('helloworld',file=fp)
    fp.close
    

• 输出形式

  • 默认为换行，分隔符为空格

  • 利用end参数不换行

    • print(i, end = '')
    • 默认end=‘n’

  • 利用sep参数，改变分隔符

    print('hello','world','Python')
    #——>默认分隔符为空格：hello world Python
    print('hello','world','Python',sep=',')
    #——>以,为分隔符输出：hello,world,Python
    

6. 转义字符

• 反斜杠+想要实现的转义功能首字母

• print('hellonworld')
  print('hellotworld')  #四个字符为一个制表位，hell占四个字符，o占一个字符，所以t就空3个字符
  print('hellooootworld')  #hell占四个字符，oooo占四个字符，所以t新开一个制表位，空4字符
  print('hellorworld')  #world将hello进行了覆盖
  print('hellobworld')  #b十退一个格，将o退没了
  

• 输出特殊符号

• print('http:\\www.baidu.com')
  print('老师说：'上课了')
  

• 原字符

  • 不希望字符串中的转义字符起作用，就使用原字符

  • 只要在字符串之前加上r或R

  • print(r'hellonworld')
    

  • 注意事项，最后一个字符不能是一个反斜杠，两个可以

第二站 七十二变 1. 二进制与字符编码

• 1字节=8bite

• ASCII码，使用1字节的后7位，最高位不适用，共有2⁷=128个组合，即128个字符

• ASCII码表

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-becjOEw7-1654480754322)(D:softwareTyporaimageimage-20220125154511619.png)]

• 常见的对应关系：

  • A-65
  • a-97
  • 0-48

• 二进制与字符编码

  • 二进制0，1——>ASCII——>GB2312——>GBK——>GB18030——>万国码Unicode——>UTF-8

  • UTF-8

    • 中文使用3字节表示

    • 英文使用1字节表示

      print(ord('乘'))-->20056
      print(chr(20056))-->乘
      20056-->0b100111001011000
      print(chr(0b100111001011000))-->乘
      

2. 标识符和保留字

• 标识符

  • 变量、函数、类、模块和其他对象起的名字就叫标识符
  • 规则：
    • 字母、数字、下划线
    • 不能以数字开头
    • 不能是保留字
    • 严格区分大小写

• 保留字

  • 有一些单词被赋予特定的意义

  • import keyword
    print(keyword.kwlist)
    ['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
    

3. 变量的定义和使用

• 变量是内存中一个带标签的盒子

• 变量名 赋值运算符 值

  • eg：name = ‘test’

• 组成：

  • 标识：表示对象所存储的内存地址，使用内置函数id(obj)来获取
  • 类型：表示的是对象的数据类型，使用内置函数type(obj)来获取
  • 值：表示对象所存储的具体数据，使用print(obj)可以将值进行打印输出

• name = 'test'
  print('标识：',id(name))
  print('类型：',type(name))
  print('值：',name)
  

• 当多次复制之后，变量名会指向新的空间(id)

  • 而变量原来指向的内存空间则称为内存垃圾，将有python的垃圾回收机制回收

4. 常见的数据类型 4.1. 整数类型int

• 十进制：默认的进制
• 二进制：以0b开头
• 八进制：以0o开头
• 十六进制：以0x开头

4.2. 浮点数类型float

• 浮点数：整数部分+小数部分组成

• 浮点数存储不精确

  • 使用浮点数进行计算时，可能会出现小数位数不确定的情况

  • print(1.1 + 2.2)     #3.3000000000000003
    print(1.1 + 2.1)     #3.2
    

  • 解决方法：

    • 导入模块decimal

    • from decimal import Decimal
      print(Decimal('1.1') + Decimal('2.2'))     #3.3
      

4.3. 布尔类型bool

• 用来表示真或假的值

• True表示真，False表示假

• f1 = True
  f2 = False
  print(f1, type(f1))
  print(f2, type(f2))
  
  #布尔值可以转成整数计算
  print(f1 + 1)   #2 ————> True表示1
  print(f2 + 1)   #1 ————> False表示2
  

4.4. 字符串类型str

• 字符串又被称为不可变的字符序列

• 可以使用单引号，双引号，三单引号和三双引号来定义

• 单引号和双引号定义的字符串必须在一行显示

• 三单引号和三双引号定义的字符串可以分布再连续的多行

• str1 = '人生苦短，我用python'
  str2 = "人生苦短，我用python"
  str3 = '''人生苦短，
  我用python'''
  str4 = """人生苦短，我用python"""
  

4.5. 数据类型转换

• 可以将不同数据类型的数据拼接在一起

• name = '张三'
  age = 20
  print('我叫' + name + '，今年' + str(age) + '岁。')
  

• 数据类型转换的函数

• 函数名	作用	注意事项	举例
  str()	将其他数据类型转成字符串	也可以用引号进行转换	str(123)，‘123’
  int()	将其他数据类型转成整数	①文字类和小数类字符串，无法转成整数。②浮点数转成整数：抹零取整	int(‘123’)，int(9.8)
  float()	将其他数据类型转成浮点数	①文字类无法转成整数。②整数转成浮点数，末尾为.0	float(‘9.9’)，float(9)

5. 注释

• 在代码中对代码的功能进行解释说明的标注行文字，可以提高代码的可读性

• 注释的内容会被python解释器忽略

• 通常包括三种类型的注释

  • 单行注释 ——> 以 “ # ” 开头，直到换行结束

  • 多行注释 ——> 并没有单独的多行注释标记，将一对三引号之间的代码称为多行注释

  • 中文编码声明注释 ——> 在文件开头加上中文生命注释，用以指定源码文件的编码格式

    • # -*- coding:utf-8 -*-
      # coding:gbk
      

第三站 算你赢 1. 输入函数input()

• 作用：接收来自用户的输入

• 返回值类型：输入值的类型为str

• 值的存储：使用=对输入的值进行存储

• input()函数的基本使用：

  present = input('大圣想要什么礼物呢?')
  print(present)
  
  a = input('请输入一个整数：')
  b = input('请再输入一个整数：')
  print(int(a) + int(b))
  
  a = int(input('请输入一个整数：'))
  b = int(input('请再输入一个整数：'))
  print(a + b)
  

2. 常用的运算符 2.1. 算术运算符 2.1.1. 标准运算符

• 加+

• 减-

• 乘*

• 除/

• 整除//

  • ==一正一负整除向下取整==
    print(9 // -4)   #3
    print(-9 // 4)   #3
    

2.1.2. 取余运算符

• %

  • 余数 = 被除数 - 除数 * (被除数 // 除数)
    print(9 % -4)  #-3
    print(-9 % 4)  #3
    

2.1.3. 幂运算符

• **

2.2. 赋值运算符=

• 运算执行顺序：从右到左

• 支持链式赋值

  • a = b = c = 20，将20分别赋值给a,b,c

• 支持参数赋值

  • a = 20
    a += 30   #相当于a = a + 30
    a -= 10   #相当于a = a - 10
    a *= 2    #相当于a = a * 2
    a /= 3    #相当于a = a / 2
    a //= 2   #相当于a = a // 2
    a %= 2    #相当于a = a % 2
    

• 支持系列解包赋值

  • a,b,c = 20,30,40

  • 要求等号左边的个数等于右边的个数

  • 交换两个变量的值

    a,b = 10,20
    print('交换之间:',a,b)
    a,b = b,a
    print('交换之后:',a,b)
    

2.3. 比较运算符

• 对变量或表达式的结果进行大小、真假等的比较

• 比较运算符的结果为bool类型，True或False

• >，<，>=，<=，==，!=，==，is，is not

  • ‘’’

    一个 = 称为赋值运算符，两个 == 称为比较运算符

    一个变量由三部分组成：标识、类型、值

    == 比较的是变量的值

    is 关键字，比较的是变量的标识

    ‘’’

    a,b = 10,10
    print(a == b) #True
    print(a is b) #True
    
    lst1 = [11, 22, 33, 44]
    lst2 = [11, 22, 33, 44]
    print(lst1 == lst2) #True
    print(lst1 is lst2) #Flase
    print(id(lst1), id(lst2))
    print(lst is not lst2) #True
    

2.4. 布尔运算符

• and 与

  • 当两个运算数都为True时，运算结果才为True；否则为False

  • a,b = 1,2
    print(a==1 and b==2) #True
    print(a==1 and b<2)  #False
    print(a!=1 and b==2) #False
    print(a!=1 and b!=2) #False
    

• or 或

  • 只要有一个运算数为True，运算结果就为True；否则为False

  • a,b = 1,2
    print(a==1 or b==2) #True
    print(a==1 or b<2)  #True
    print(a!=1 or b==2) #True
    print(a!=1 or b!=2) #False
    

• not 非

  • 如果运算数为True，运算结果为False；如果运算数为False，运算结果为True

  • #not:对bool类型操作数进行取反
    f1 = True
    f2 = False
    print(not f1) #False
    print(not f2) #True
    

• in

  • s = 'helloworld'
    print('w' in s) #True
    print('hello' in s) #True
    print('k' in s) #False
    

• not in

  • print('k' not in s) #True
    

2.5. 位运算符

• 将数据转成二进制进行运算
• 按位与 &
  • 对应数位都是1，结果数位才是1，否则为0
• 按位或 |
  • 对应数位都是0，结果数位才是0，否则为1
• 左移位运算符 <<
  • 高位溢出舍弃，低位补0
• 右移位运算符 >>
  • 低位溢出舍弃，高位补0

2.6. 运算符的优先级

第四站 往哪走 1. 程序的组织结构

• 任何简单或复杂的算法都可以由顺序结构、选择结构和循环结构这三种基本结构组成
• 顺序结构
• 选择结构——>if语句
• 循环结构——>while语句、for-in语句

2. 顺序结构

• 程序从上到下顺序地执行代码，中间没有任何的判断和跳转，直到程序结束

  '''把大象装冰箱一共分几步'''
  print('---------程序开始----------')
  print('1.把冰箱门打开')
  print('2.把大象放冰箱里')
  print('3.把冰箱门关上')
  print('---------程序结束----------')
  

3. 对象的布尔值

• Python一切皆对象，所有对象都有一个布尔值

  • 获取对象的布尔值
    • 使用内置函数bool()

• 以下对象的布尔值为False：

  • False
  • 数值0
  • None
  • 空字符串
  • 空列表
  • 空元组
  • 空字典
  • 空集合

• 其他对象的布尔值均为True

• 所以对象可以直接作为条件表达式

  age = int(input('请输入你的年龄：'))
  if age:
      print(age,'岁')
  else:
      print('输入错误')
  

4. 选择/分支结构

• 程序根据判断条件的布尔值选择性地执行部分代码，明确的让计算机知道在什么条件下，该去做什么

4.1. 单分支if结构

• 中文语义：如果……就……

• 语法结构：

  if 条件表达式：
  	条件执行体
  

• demo：

  money = 1000
  s = int(input('请输入取款金额'))
  #判断余额是否充足
  if money >= s:
      money = money -s
      print('取款成功，余额为：',money)
  

4.2. 双分支if…else结构

• 中文语义：如果……就……；不满足……就……

• 语法结构：

  if 条件表达式：
  	条件执行体1
  else：
  	条件执行体2
  

• demo：

  '''从键盘录入一个整数，编写程序让计算机判断是否为奇数还是为偶数'''
  num = int(input('请输入一个整数'))
  if num % 2 == 0:
      print(num,'是偶数')
  else:
      print(num,'是奇数')
  

4.3. 多分支if…elif…else结构

• 成绩是在90分以上吗？ #不是

  成绩是在80到90分之间吗？#不是

  成绩是在70到80分之间吗？#不是

  成绩是在60到70分之间吗？#不是

  成绩是在60分以下吗？ #是

• 语法结构

  if 条件表达式1:
  	条件执行体1
  elif 条件表达式2:
  	条件执行体2
  elif 条件表达式N:
  	条件执行体N
  [else:]
  	条件执行体N+1
  

• demo

  '''从键盘录入一个整数成绩，判断成绩的等级'''
  score = int(input('请输入一个整数:'))
  if score >= 90 and score <= 100: # 90 <= score <= 100
      print('A')
  elif score >= 80 and score < 90: # 80 <= score < 90
      print('B')
  elif score >= 70 and score < 80: # 70 <= score < 80
      print('C')
  elif score >= 60 and score < 70: # 60 <= score < 70
      print('D')
  elif score >= 0 and score < 60:  # 0 <= score < 60
      print('E')
  else:
      print('您的输入不在成绩的有效范围')
  

4.4. If语句的嵌套

• 语法结构：

• demo

  '''
  会员购物金额>=200,8折；>=100,9折;否则不打折。
  非会员购物金额>=200,9.5折。
  '''
  answer = input('您是会员吗？y/n')
  money = float(input('请输入您的购物金额：'))
  if answer == 'y':
      print('会员')
      if money >= 200:
          print('打8折，付款金额：',money*0.8)
      elif money >= 100:
          print('打9折，付款金额：',money*0.9)
      else:
          print('不打折，付款金额：',money)
  else:
      print('非会员')
      if money >= 200:
          print('打9.5折，付款金额：',money*0.95)
      else:
          print('不打折，付款金额：',money)
  

4.5. 条件表达式

• 条件表达式是if……else……的简写

• 语法结构

  • x if 判断条件 else y

• 运算规则

  • 如果判断条件的布尔值为True，条件表达式的返回值为x；否则条件表达式的返回值为False

• demo

  num_a = int(input('请输入一个整数：'))
  num_b = int(input('请再输入一个整数：'))
  if num_a >= num_b:
      print(num_a,'大于等于',num_b)
  else:
      print(num_a,'小于',num_b)
  
  print('--使用条件表达式进行比较--')
  print((num_a,'大于等于',num_b) if num_a>=num_b else (num_a,'小于',num_b))
  

5.pass空语句

• 语句什么都不做，只是一个占位符，用在语法上需要语句的地方

• 什么时候使用：

  先搭建语法结构，还没想好代码怎么写的时候

• 哪些语句一起使用

  • if语句的条件执行体
  • for-in语句的循环体
  • 定义函数时的函数体

第五站 转圈圈 1. range()函数的使用

• 是一个内置函数，之前的print()、input()也是内置函数

• 用于生成一个整数序列

• 创建range对象的三种方式

  • range(stop)：默认从0开始，即 [0, stop) 区间的所有整数

  • range(start, stop)

  • range(start, stop, step)

  print('--------第一种方法---------')
  r1 = range(10) #[0，1，2，3，4，5，6，7，8，9]，默认从0开始，默认相差1称为步长
  print(r1) #range(0，10)
  print(list(r1)) #用于查看range对象中的整数序列
  
  print('--------第二种方法---------')
  r2 = range(1, 10) #指定了起始值，从1开始，到10结束(不包含10)，默认步长为1
  print(list(r2)) #[1，2，3，4，5，6，7，8，9]
  
  print('--------第三种方法---------')
  r3 = range(1, 10, 2)
  print(list(r3)) #[1，3，5，7，9]
  
  print('--判断指定的整数在序列中是否存在in，not in--')
  print(10 in r3) #Fasle
  print(9 in r3) #True
  
  print(10 not in r3) #True
  print(9 not in r3) #Fasle
  

• 返回值是一个迭代器，直接打印无法查看该对象里面的内容

• in 与 not in 判断整数序列中是否存在（不存在）指定的整数

• range类型的优点：不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的，因为仅仅需要存储start、stop、step，只有当用到range对象时，才会去计算序列中的相关元素

2. 循环结构

• 反复做同一件事情的情况，称为循环
• 循环结构的流程图
• 循环的分类
  • while
  • for -in

3. while循环

• 语法结构

  while 条件表达式:
  	条件执行体(循环体)
  

• demo

  a = 1
  while a <= 10:
      print(a)
      a += 1
  

• 选择结构的if与循环结构结构while的区别

  • if是判断一次，条件为True执行
  • while是判断N+1次，条件为True执行N次

• 四部循环法

  • 初始化变量
  • 条件判断
  • 条件执行体（循环体）
  • 改变变量

  '''求1-100之间的偶数和'''
  a = 1
  sum = 0
  while a <= 100:
      if a % 2 == 0:
          sum += a
      a += 1
  print(sum)
  

4. for循环

• in 表达从（字符串、序列等）中依此取值，又称为遍历

• for -in 遍历的对象必须是可迭代对象

• 语法结构

  for 自定义的变量 in 可迭代对象：
  	循环体
  

• demo1

  for item in 'Python': #第一次取出来的是P，将P赋值给item，将item的值输出
      print(item)
  
  #range()产生一个整数序列，也是一个可迭代对象
  for i in range(10):
      print(i)
  

• 循环体内不需要访问自定义变量，可以将自定义变量替代为下划线_

  for _ in range(5):
      print('人生苦短，我用Python')
  
  sum = 0
  for i in range(0, 101, 2):
      sum += i
  

• demo2

  '''
  输出100到999之间的水仙花数
  举例：
  153 = 3*3*3 + 5*5*5 + 1*1*1
  '''
  
  sum = 0
  for i in range(100, 1000):
      ge = i % 10
      shi = i % 100 // 10
      bai = i // 100
      if i == ge**3 + shi**3 + bai**3:
          sum += 1
          print('水仙花数：',i)
  print('水仙花数总共有：',sum,'个',sep='')
  

5. break和continue语句 5.1. break语句

• 用于结束循环结束，通常与分支结构if一起使用

  • for ... in ...:
        ......
        if ...:
            break
    

  • while (条件):
        ......
        if ...:
            break
    

• demo

  for i in range(3):
      pwd = input('请输入密码:')
      if pwd == '8888':
          print('密码正确')
          break
  	else:
          print('密码不正确')
  
  a = 0
  while a < 3:
      pwd = input('请输入密码:')
      if pwd == '8888':
          print('密码正确')
          break
  	else:
          print('密码不正确')
  	a += 1
  

5.2. contibue语句

• 用于结束当前循环，进入下一次循环，通常与分支结构中的if一起使用

• demo

  #要求: 使用 contibue 输出1-50之间所有5的倍数
  for i in range(1, 51):
      if i % 5 != 0:
          continue
  	print(i)
  

6. else语句

• 与else语句配合使用的三种情况

• for i in range(3):
      pwd = input('请输入密码：')
      if pwd == '8888':
          print('密码正确')
          break
  	else:
          print('密码错误')
  else:
      print('三次密码输入错误')
  

• a = 0
  while a < 3:
      pwd = input('请输入密码:')
      if pwd == '8888':
          print('密码正确')
          break
  	else:
          print('密码不正确')
  	a += 1
  else:
      print('三次密码输入错误')
  

7. 嵌套循环

• 循环结构中又嵌套了另外的完整的循环结构，其中内层循环作为外层循环的循环体执行

• demo1

  for x in range(3):
      for y in range(4):
          print('*', end='t')
      print()
  

• demo2

  for i in range(1, 10):
      for j in range(i):
          print('*',end='')
      print()
  

• demo3

  # 输出九九乘法表
  x = 1
  for i in range(9):
      y = 1
      for j in range(x):
          print(x, '*', y, '=', x*y, end='t')
          y += 1
      x += 1
      print()
  

8. 二重循环中break和continue

• 二重循环中的break和continue用于控制本层循环

第六站 一字排开-列表

• 为什么需要列表

  • 变量可以存储一个元素，而列表是一个“大容器”可以存储N多个元素，程序可以方便地对这些数据进行整体操作

  • 列表是一个可变有序序列，可以进行增删改操作

  • 列表相当于其他语言中的数组

  • 列表示意图

  • 列表内存存储示意图

    eg: lst = ['hello', 'world', 98]

1. 列表的创建与删除

• 列表的两种创建方式：

  • ①使用中括号

  • ②调用内置函数list()

    • lst = list(['hello', 'world', '98'])
      print(lst)
      #['hello', 'world', '98']
      

• 列表需要使用中括号[]，元素之间使用英文的逗号进行分隔

2. 列表的特点

• 列表元素按顺序有序排序
• 索引映射唯一一个数据
• 列表可以存储复杂数据
• 任意数据类型混杂
• 根据需要动态分配和回收内存
  • 按照元素的多少动态分配内存空间

3. 列表的查询操作 3.1. 获取指定元素的索引

• 获取列表中指定元素的索引——> index()方法

  • 如果列表中存储N个相同元素，只返回相同元素中的第一个元素的索引
  • 如果查询的元素在列表中不存在，则会抛出ValueError异常
  • 还可以在指定的start和stop之间进行查找

  lst = ['hello', 'world', 98, 'hello']
  print(lst.index('hello'))
  
  #在指定的start和stop之间进行查找：
  print(lst.index('hello', 1, 4))
  

3.2. 获取单个元素

• 获取列表中的单个元素

  • 正向索引从0到N-1

  • 逆向索引从-N到-1

  • 指定索引不存在，排除IndexError异常

  lst = ['hello', 'world', 98, 'hello', 'world']
  print(lst[2]) #98
  print(lst[-3]) #98
  

3.3. 获取多个元素-切片

• 获取列表中的多个元素——切片操作

• 语法格式：列表名[start: stop: step]

  • 切片的结果——>原列表片段的拷贝

    >>> lst = [10, 20, 30, 40, 50]
    >>> lst2 = lst[::]
    >>> print(lst2)
    [10, 20, 30, 40, 50]
    >>> print(id(lst))
    2012214231360
    >>> print(id(lst2))
    2012216670720
    

  • 切片的范围——> [start, stop) 区间

  • step默认为1 ——> 简写为 [start: stop]

  • step为正数：从start开始往后计算切片

    • [: stop: step]：切片的第一个元素默认是列表的第一个元素

    • [start: : step]：切片的最后一个元素默认是列表的最后一个元素

    >>> lst = [10, 20, 30, 40, 50, 60]
    >>> print(lst[::])
    [10, 20, 30, 40, 50, 60]
    >>> print(lst[0:6])
    [10, 20, 30, 40, 50, 60]
    >>> print(lst[:6])
    [10, 20, 30, 40, 50, 60]
    

• step为负数：从start开始往前计算切片

  • [: stop: step]：切片的第一个元素默认是列表的最后一个元素

  • [start: : step]：切片的最后一个元素默认是列表的第一个元素

    >>> lst = [10, 20, 30, 40, 50, 60]
    >>> print(lst[::-1])
    [60, 50, 40, 30, 20, 10]
    >>> print(lst[5::-1])
    [60, 50, 40, 30, 20, 10]
    >>> print(lst[:-7:-1])
    [60, 50, 40, 30, 20, 10]
    

  • 简便方法：列表逆序后看成步长为正数的切片操作

    • 遇到步长为负数的切片操作时，首先将列表逆序
    • 在逆序的列表中，根据stop位置索引找到切片操作的起点，但是注意不包括这个stop位置的索引
    • 在逆序的列表中，根据start位置索引找到切片操作的终点，包括这个start位置的索引
    • 最后，根据起点、终点和步长(看成正数)，由逆序列表写出切片后的列表

3.4. 其他

• 判断元素在列表中是否存在
  • in 和 not in
  • 元素 in 列表名
  • 元素 not in 列表名

>>> lst = [10, 20, 'python']
>>> print('python' in lst)
True
>>> print('py' in lst)
False
>>> print(10 in lst)
True

• 列表元素的遍历

for 迭代变量 in 列表名:
    操作

lst = [10, 20, 'python']
for i in lst:
    print(i)
'''
10
20
python
'''

4. 列表元素的添加操作

append()：在列表的末尾添加一个元素

extend()： 在列表的末尾至少添加一个元素

insert()： 在列表的任意位置添加一个元素，insert(索引位置, 元素)

切片： 在列表的任意位置添加至少一个元素，但会删除一部分元素

• append() 方法

  lst = [10, 20, 30]
  print('添加元素之前',lst) #[10, 20, 30]
  id1 = id(lst)
  lst.append(100)
  print('添加元素之后',lst) #[10, 20, 30, 100]
  id2 = id(lst)
  print(id1 == id2) #True
  

• extend() 方法

  lst = [10, 20, 30]
  lst2 = ['hello', 'world']
  '''
  lst.append(lst2) #将lst2作为一个元素添加到列表的末尾
  print(lst)
  #[10, 20, 30, ['hello', 'world']]
  '''
  lst.extend(lst2) #将lst2的多个元素添加到列表的末尾
  print(lst)
  #[10, 20, 30, 'hello', 'world']
  

• insert() 方法

  lst = [10, 20, 30]
  lst.insert(1, 90)
  print(lst)
  #[10, 90, 20, 30]
  

• 切片

  lst = [10, 20, 30, 40, 50]
  lst3 = ['python', 'hello']
  lst[1::] = lst3
  print(lst)
  #[10, 'python', 'hello']
  

5. 列表元素的删除操作

• ① remove()方法

  • 一次删除一个元素
  • 重复元素只删除第一个
  • 元素不存在则抛出ValueError

  >>> lst = [10, 20, 30, 40, 50, 60]
  >>> lst.remove(30)
  >>> print(lst)
  [10, 20, 40, 50, 60]
  

• ② pop()方法

  • 删除一个指定索引位置上的元素
  • 指定索引不存在则抛出IndexError
  • 不指定索引，删除列表中最后一个元素

  >>> lst = [10, 20, 30, 40, 50, 60]
  >>> lst.pop(2)
  >>> print(lst)
  [10, 20, 40, 50, 60]
  >>> lst.pop()
  >>> print(lst)
  [10, 20, 40, 50]
  

• ③ clear()方法

  • 清空列表

  >>> lst = [10, 20, 30, 40, 50, 60]
  >>> lst.clear()
  >>> print(lst)
  []
  

• ④ 切片

  • 切片操作本身一次至少删除一个元素，将产生一个新的列表对象

  >>> lst = [10, 20, 30, 40, 50, 60]
  >>> newlst = lst[1:3]
  >>> print(newlst)
  [10, 40, 50, 60]
  

  • 不产生新的列表对象，而是删除原列表中的内容

  >>> lst = [10, 20, 30, 40, 50, 60]
  >>> lst[1:3] = []
  >>> print(lst)
  [10, 40, 50, 60]
  

• ⑤del

  • 删除列表

  >>> lst = [10, 20, 30, 40, 50, 60]
  >>> del lst
  

6. 列表元素的修改操作

• 列表元素的修改操作

  • 为指定索引的元素赋予一个新值

  lst = [10, 20, 30, 40]
  lst[2] = 100
  print(lst)
  #[10, 20, 100, 40]
  

  • 为指定的切片赋予一系列新值

  lst = [10, 20, 30, 40]
  lst[1:3] = [300, 400, 500] #将索引为1-2的两个元素替换为300，400，500这三个元素
  print(lst)
  #[10, 300, 400, 500, 40]
  

7. 列表元素的排序操作

• 列表元素的排序操作

  • 常见的两种方式
    • 调用sort()方法，列表中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True，进行降序排序
    • 调用内置函数sorted()，可以指定reverse=True，进行降序排序，产生一个新列表对象，原列表不发生变化

  #调用sort()方法
  lst = [20, 40, 10, 98, 54]
  print('排序前的列表',lst)
  #升序排序
  lst.sort()
  print('排序后的列表',lst)
  #降序排序
  lst.sort(reverse=True)
  print('排序后的列表',lst)
  

  #调用内置函数sorted()
  lst = [20, 40, 10, 98, 54]
  #升序排序
  newlst = sorted(lst)
  print(newlst)
  #降序排序
  deslst = sorted(lst, reverse = True)
  print(deslst)
  

8. 列表生成式

• 即生成列表的公式

  • 语法格式
  • 注意事项：“表示列表元素的表达式”一般含有自定义变量

• demo

>>> lst = [i for i in range(1, 10)]
>>> print(lst)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> lst2 = [i*i for i in range(1, 10)]
>>> print(lst2)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

第七站 夫妻站-字典

• 什么是字典

  • Python内置的数据结构之一，与列表一样是一个可变序列

  • 以键值对{key:value}的方式存储数据，字典是一个无序序列

  • eg：scores = {‘张三’: 100, ‘李四’: 98, ‘王五’:45}

  • 字典示意图

    在往字典里面存储数据时，需要经过hash函数的工序，也即把‘键’放入hash函数中进行计算，得出键的存储位置，因此也要求放在字典中的键是一个不可变序列，如字符串、range整数序列等，不可以进行增删改的操作

  • 字典的实现原理

    字典的实现原理与查字典类似，查字典是先根据部首或拼音查找汉字对应的页码，Python中的字典是根据key查找value所在的位置

1. 字典的创建

• 最常用的方式：使用花括号

  scores = {'张三': 100, '李四': 98, '王五':45}
  #空字典：{}
  

• 也可以使用内置函数dict()

  • 由于参数中是赋值的形式，键不需要引号(默认就是字符串)，值根据数据类型添加引号

  zd = dict(name = 'jack', age = 20)
  print(zd)
  #{'name': 'jack', 'age': 20}
  

2. 字典中元素的获取

• []

  scores = {'张三': 100, '李四': 98, '王五':45}
  print(scores['张三'])
  #100
  

• get{}方法

  scores = {'张三': 100, '李四': 98, '王五':45}
  print(scores.get('张三'))
  #100
  

• 区别：

  • []如果字典中不存在指定的key，抛出keyError异常
  • get()方法取值，如果字典中不存在指定的key，并不会抛出keyError异常，而是返回None。但可以通过参数设置默认的value，以便指定的key不存在时返回。

  scores = {'张三': 100, '李四': 98, '王五':45}
  print(scores.get('赵六',99)) #指定的key赵六不存在时返回值99
  #99
  

3. 键的判断

• in
• not in

scores = {'张三': 100, '李四': 98, '王五':45}
print('张三' in score) #True
print('张三' not in score) #False

4. 字典元素的删除

• del

scores = {'张三': 100, '李四': 98, '王五':45}
del scores['张三']
print(scores)
#{'李四': 98, '王五':45}

• clear 清空字典中的元素

score.clear()

5. 字典元素的新增和修改

scores = {'张三': 100, '李四': 98, '王五':45}
scores['赵六'] = 78 #字典元素的新增
print(scores)
#{'张三': 100, '李四': 98, '王五': 45, '赵六': 78}
scores['赵六'] = 87 #字典元素的修改
print(scores)
#{'张三': 100, '李四': 98, '王五': 45, '赵六': 87}

6. 获取字典视图的方法

• keys() 获取字典中所有key，得到一个dict_keys类型对象，可以用list方法将所有的key组成的视图转成列表

  scores = {'张三': 100, '李四': 98, '王五':45}
  jian = scores.keys()
  print(type(jian))
  print(list(jian))
  '''
  dict_keys(['张三', '李四', '王五'])
  
  ['张三', '李四', '王五']
  '''
  

• values() 获取字典中所有value，得到一个dict_values类型对象，也可以用list方法将所有的value组成的视图转成列表

  scores = {'张三': 100, '李四': 98, '王五':45}
  zhi = scores.values()
  print(type(zhi))
  print(list(zhi))
  '''
  dict_values([100, 98, 45])
  
  [100, 98, 45]
  '''
  

• items() 获取字典中所有key,value对，得到一个dict_items类型对象，也可以用list方法将所有的value组成的视图转成列表，其中的键值对以元组形式存储

  scores = {'张三': 100, '李四': 98, '王五':45}
  i = scores.items()
  print(type(i))
  print(list(i))
  '''
  dict_items([('张三', 100), ('李四', 98), ('王五', 45)])
  
  [('张三', 100), ('李四', 98), ('王五', 45)]
  '''
  

7. 字典元素的遍历

• #输出字典的键：
  for item in scores:
      print(item)
  

• ##输出字典的值：
  for item in scores:
      print(scores[item])
  #或者：
  for item in scores:
      print(scores.get(item))
  

8. 字典的特点

• 字典中的所有元素都是一个键值对，value值可以重复，key键不允许重复
• 字典中的元素是无序的
• 字典中的key必须是不可变对象
  • 例如将列表作为字典的键会报错
• 字典也可以根据需要动态地伸缩
  • 所分配的内存空间根据元素的增加进行伸缩
• 字典会浪费比较大的内存，是一种使用空间换时间的数据结构
  • 字典的实现原理部分

9. 字典生成式

• 内置函数zip()
  • 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表

items = ['Fruits', 'Books', 'Others']
prices = [98, 78, 89, 100]

d = {item.upper():price for item, price in zip(items, prices)}
print(d)
# {'FRUITS': 98, 'BOOKS': 78, 'OTHERS': 89}

第八站 是排还是散-元组&集合 1. 什么是元组

• 元组——Python内置的数据结构之一，是一个不可变序列

  • 注意：元组存储的是对象的引用
    • 如果元组中对象本身是不可变对象，则不能再引用其他对象
    • 如果元组中对象本身是可变对象，则可变对象的引用不允许改变，但可以去改变所引用对象本身的值

• 可变序列与不可变序列

  • 可变序列：列表、字典
    • 可以对序列执行增、删、改操作，对象地址不发生更改
  • 不可变序列：字符串、元组
    • 没有增、删、改的操作
    • 在多任务环境下，同时操作对象时不需要加锁(可变序列在多任务环境下需要轮流进行操作)，因此在程序中尽量使用不可变序列

#可变序列：列表、字典
lst = [10, 20, 45]
print(id(lst))
lst.append(300)
print(id(lst))

#不可变序列：字符串、元组
s = 'hello'
print(id(s))
s = s + 'world'
print(id(s))

2. 元组的创建方式

• 直接使用小括号创建一个元组

• eg：t = ('python', 98)

• 使用tuple()函数创建一个元组

  • eg：t1 = tuple(('python', 98))

• 注意事项

  • 只包含一个元组的元素需要使用逗号和小括号

  t0 = 'Python'
  print(type(t0)) #
  
  t1 = ('Python')
  print(type(t1)) #
  
  t2 = ('Python',)
  print(type(t2)) #tuple
  

  • 空元组：t1 = ()、t2 = tuple()

3. 元组的遍历

• 可以使用下标的方式逐个输出元组内部的数据
• 可以使用for…in…实现对元组内部数据的遍历

t = ('Python', 'world', 98)
for i in t:
    print(i)

>>> print(t[0])
Python
>>> print(t[1])
world
>>> print(t[2])
98

4. 什么是集合

• Python语言提供的内置数据结构
• 与列表、字典一样都属于可变类型的序列
• 集合是没有value的字典，使用哈希函数去计算存储的地址，所以集合的元素的值不能重复

5. 集合的创建方式

• 直接使用花括号{}
  • 集合中的元素不允许重复
• 使用内置函数set()

s0 = {1, 2, 3, 4, 5}

s1 = set(range(6))
print(s1) #{0, 1, 2, 3, 4, 5}

s2 = set([1, 1, 2, 2, 3, 4, 5, 5])
print(s2) #{1, 2, 3, 4, 5}，将列表转换成集合，并删除列表中的重复元素

s3 = set((1, 2, 3, 4, 4, 5, 65))
print(s3) #{65, 1, 2, 4, 5}，将元组转换成集合，集合是无序的

s4 = set('python')
print(s4) #{'o', 't', 'p', 'h', 'y', 'n'}，将字符串转化为集合

s5 = {}
print(type(s5)) #

s6 = set()
print(type(s6)) #，定义一个空集合

6. 集合元素的判断操作

• in 或 not in

7. 集合元素的新增操作

• 调用 add() 方法，一次添加一个元素
• 调用 update() 方法至少添加一个元素

s = {10, 39, 78, 90}
s.add(95)
print(s) #{39, 10, 78, 90, 95}

s.update({97, 98})
print(s) #{97, 98, 39, 10, 78, 90, 95}

s.update([99, 100])
print(s) #{97, 98, 99, 100, 39, 10, 78, 90, 95}

8. 集合元素的删除操作

• 调用 remove() 方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError
• 调用discard() 方法，一次删除一个指定元素，如果指定的元素不存在不抛出异常
• 调用 pop() 方法，一次只删除一个任意元素（不能添加参数）
• 调用 clear() 方法，清空集合中的所有元素

9. 集合之间的关系

• 两个集合是否相等（元素相同就相等）
  • 可以使用运算符 == 或 != 进行判断
• 一个集合是否是另一个集合的子集
  • 可以调用方法issubset进行判断
• 一个集合是否是另一个集合的超集
  • 可以调用方法issuperset进行判断
  • B是A的子集，则A是B的超集
• 两个集合是否没有交集
  • 可以调用方法isdisjoint进行判断
  • 注意：这里有交集时结果为false，无交集时结果为true

10. 集合的数据操作

• 交集

s1 = {10, 20, 30, 40}
s2 = {20, 30, 40, 50, 60}
print(s1.intersection(s2))
print(s1 & s2)
#intersection()与 & 等价，交集操作
#{40, 20, 30}

• 并集

print(s1.union(s2))
print(s1 | s2)
#union()与 | 等价，并集操作
#{40, 10, 50, 20, 60, 30}

• 差集

print(s1.difference(s2))
print(s1 - s2)
#difference()与 - 等价，差集操作
#{10}

• 对称差集

print(s1.symmetric_difference(s2))
print(s1 ^ s2)
#symmetric_difference()与 ^ 等价，对称差集操作
#{50, 10, 60}

11. 集合生成式 12. 总结 第九站 一串连一串-字符串

• 在Python中，字符串是基本数据类型，是一个不可变的字符串序列

1. 字符串驻留机制

• 仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量。

a = 'Python'
b = "Python"
c = '''Python'''
print(id(a)) #2398209421744
print(id(b)) #2398209421744
print(id(c)) #2398209421744

• 驻留机制的几种情况（交互模式）
  • 字符串的长度为0或1时
  • 符合标识符的字符串
  • 字符串只在编译时进行驻留，而非运行时
  • [-5, 256] 之间的整数数字
• sys 中的 intern 方法强制2个字符串指向同一个对象
• PyCharm对字符串进行了优化处理

75