Welcome to Xin YAO's blog

• 函数基础01

  2018-08-29

  Python

  函数

  推荐一个网址：http://pythontutor.com/visualize.html#mode=edit 可以在线运行代码，观看执行过程，很好用。 —— 没有函数，出现的问题是什么？ 1、同样的代码需要些多次。 2、一个功能的需求发生改变，需要修改多个地方。

  • 定义：函数就是对实现某一特定功能的代码段的封装。
  • 作用：提高代码的复用度，让代码更简洁。

    一、函数分类

  • 内置函数：系统写好的，可以直接使用的函数。例如 print函数、input函数、sum函数等。
  • 自定义函数：程序员自己创建的函数

    二、函数的说明

    1、固定格式：

    def 函数名（参数列表）:
    函数的说明文档
    函数体
    

    说明文档的格式：

    def download(url):
      """
      在这里写说明文档（函数功能描述）
      :param url:下载数据的地址（对参数说明）
      :return:None（返回值的说明）
      """
    

    2、 函数组成说明：

  • def：python中声明函数的关键字。
  • 函数名：标识符，不能是关键字。（规范：PEP8规则，见名知义）
  • （）：固定格式，并且必须写。
  • 参数列表(行参)：参数名1，参数名2，参数名3…..（参数可以有多个，也可以不写）。 参数是用来从函数的外面，向函数里面传值用的。
  • 说明文档：说明函数功能。
  • 函数体：实现函数功能的代码段。 函数体中可能会包含return语句。

    3、初学者声明函数的过程：

    1、确定函数的功能 ===》2、根据功能确定函数的名字 ===》 3、确定参数（确定函数需不需要从函数外面传递数据进来） ===》4、实现函数功能 ===》5、确定返回值 ``` #写一个函数，打印两个数的和 def mysum(a,b): return a + b print(mysum(1,2))

  3

  ##### 4、函数的调用
  **格式：函数名（实参列表）
  函数体只有调用的时候才会执行，并且只能先声明才能调用**
  - 实参列表：就是给形参赋值的
  ##### 5、函数的调用过程（重要）
  （1）、回到函数声明的位置。
  （2）、使用实参给形参赋值（传参）。
  （3）、执行函数体。
  （4）、将返回值返回给函数调用者。
  （5）、回到函数调用的地方，接着往后执行。
  
  练习：
  

  #写一个函数，打印一个整数的阶乘 def jiecheng(n): product = 1 for index in range(1,n+1): product *= index print(product) jiecheng(5)

  结果： 120

  ##### 6、参数
  实参：
  （1）、位置参数：实参的位置和形参一一对应。
  （2）、关键字参数：通过 ‘ 形参名 = 实参 ’ 来传参。
   `func1(b='abc' , c=True , a=10)`
  （3）、关键字参数和位置结合：
  `func1(10, b=2, c=4)`
  
  **声明函数时，参数赋予默认值：**
  - 在声明函数的时候，可以参数赋默认值的。（可以参数赋默认值）
  - 给部分参数赋默认值的时候，要求有默认值的参数必须放在参数列表的最后。
  - 没有默认值的参数必须传参，有默认值的参数，可以传可以不传。
  

  def func(a, b=’a’, c=True): print(a, b, c) func(10)

  结果： 10 a True

  **不定个数参数**
  
  格式：def 函数名(*形参)
  - python中通过在形参名前面加 * ，让这个形参变成一个元组，来让这个形参可以接受多个实参。
  

  def mysum(*nums): print(nums, type(nums)) sum = 0 for item in nums: sum += item print(sum) mysum(1,2,3,4,5)

  结果： (1, 2, 3, 4, 5) <class ‘tuple’> 15

  python不能直接约束一个变量的类型。但是可以通过说明，来提示用户调用参数的时候，参数的类型。
  

  def func(name:str, age:int, study_id): print(name)

  其中str、int有提示作用
  ##### 7、函数的返回值
  - 返回值：函数的返回值就是return关键字后面表达式的结果。就是函数调用表达式的结果。
  - python中所有的函数都有返回值，默认为None（没有return）。
  

  def Pass(): pass print(Pass())

  结果： None

  - return 关键字
     1、确定返回值
     2、结束函数（函数中只要遇到return，函数就直接结束）
  
  **什么时候需要返回值？**
  只要实现函数的功能会产生新的数据，就通过返回值将新的数据返回，并不是打印它。
  
  练习：
  

  #练习：1、写一个函数，统计一个列表中整数的个数 def count1(list): count = 0 for index in list: if isinstance(index,int): count += 1 return count print(count1([1, 1.2, 3.4 ,34.5, 34, 34]))

  2、将一个数字列表中所有的元素的值都变成原来的2倍

  def list2(list_new): n = 0 for item in list_new: list_new[n] *= 2 n += 1 return list_new print(list2([2,3,4,5,6]))

  3、获取指定元素对应的下标

  def list_1(list:list, item): index_list = [] for index in range(len(list)): if list[index] == item: index_list.append(index) return index_list print(list_1([1,3,2,2,3,3],3)) 结果： 3 [4, 6, 8, 10, 12] 2 ```

  Read All

  ---

• 函数基础01

  2018-08-29

  Python

  函数

  推荐一个网址：http://pythontutor.com/visualize.html#mode=edit 可以在线运行代码，观看执行过程，很好用。 —— 没有函数，出现的问题是什么？ 1、同样的代码需要些多次。 2、一个功能的需求发生改变，需要修改多个地方。

  • 定义：函数就是对实现某一特定功能的代码段的封装。
  • 作用：提高代码的复用度，让代码更简洁。

    一、函数分类

  • 内置函数：系统写好的，可以直接使用的函数。例如 print函数、input函数、sum函数等。
  • 自定义函数：程序员自己创建的函数

    二、函数的说明

    1、固定格式：

    def 函数名（参数列表）:
    函数的说明文档
    函数体
    

    说明文档的格式：

    def download(url):
      """
      在这里写说明文档（函数功能描述）
      :param url:下载数据的地址（对参数说明）
      :return:None（返回值的说明）
      """
    

    2、 函数组成说明：

  • def：python中声明函数的关键字。
  • 函数名：标识符，不能是关键字。（规范：PEP8规则，见名知义）
  • （）：固定格式，并且必须写。
  • 参数列表(行参)：参数名1，参数名2，参数名3…..（参数可以有多个，也可以不写）。 参数是用来从函数的外面，向函数里面传值用的。
  • 说明文档：说明函数功能。
  • 函数体：实现函数功能的代码段。 函数体中可能会包含return语句。

    3、初学者声明函数的过程：

    1、确定函数的功能 ===》2、根据功能确定函数的名字 ===》 3、确定参数（确定函数需不需要从函数外面传递数据进来） ===》4、实现函数功能 ===》5、确定返回值 ``` #写一个函数，打印两个数的和 def mysum(a,b): return a + b print(mysum(1,2))

  3

  ##### 4、函数的调用
  **格式：函数名（实参列表）
  函数体只有调用的时候才会执行，并且只能先声明才能调用**
  - 实参列表：就是给形参赋值的
  ##### 5、函数的调用过程（重要）
  （1）、回到函数声明的位置。
  （2）、使用实参给形参赋值（传参）。
  （3）、执行函数体。
  （4）、将返回值返回给函数调用者。
  （5）、回到函数调用的地方，接着往后执行。
  
  练习：
  

  #写一个函数，打印一个整数的阶乘 def jiecheng(n): product = 1 for index in range(1,n+1): product *= index print(product) jiecheng(5)

  结果： 120

  ##### 6、参数
  实参：
  （1）、位置参数：实参的位置和形参一一对应。
  （2）、关键字参数：通过 ‘ 形参名 = 实参 ’ 来传参。
   `func1(b='abc' , c=True , a=10)`
  （3）、关键字参数和位置结合：
  `func1(10, b=2, c=4)`
  
  **声明函数时，参数赋予默认值：**
  - 在声明函数的时候，可以参数赋默认值的。（可以参数赋默认值）
  - 给部分参数赋默认值的时候，要求有默认值的参数必须放在参数列表的最后。
  - 没有默认值的参数必须传参，有默认值的参数，可以传可以不传。
  

  def func(a, b=’a’, c=True): print(a, b, c) func(10)

  结果： 10 a True

  **不定个数参数**
  
  格式：def 函数名(*形参)
  - python中通过在形参名前面加 * ，让这个形参变成一个元组，来让这个形参可以接受多个实参。
  

  def mysum(*nums): print(nums, type(nums)) sum = 0 for item in nums: sum += item print(sum) mysum(1,2,3,4,5)

  结果： (1, 2, 3, 4, 5) <class ‘tuple’> 15

  python不能直接约束一个变量的类型。但是可以通过说明，来提示用户调用参数的时候，参数的类型。
  

  def func(name:str, age:int, study_id): print(name)

  其中str、int有提示作用
  ##### 7、函数的返回值
  - 返回值：函数的返回值就是return关键字后面表达式的结果。就是函数调用表达式的结果。
  - python中所有的函数都有返回值，默认为None（没有return）。
  

  def Pass(): pass print(Pass())

  结果： None

  - return 关键字
     1、确定返回值
     2、结束函数（函数中只要遇到return，函数就直接结束）
  
  **什么时候需要返回值？**
  只要实现函数的功能会产生新的数据，就通过返回值将新的数据返回，并不是打印它。
  
  练习：
  

  #练习：1、写一个函数，统计一个列表中整数的个数 def count1(list): count = 0 for index in list: if isinstance(index,int): count += 1 return count print(count1([1, 1.2, 3.4 ,34.5, 34, 34]))

  2、将一个数字列表中所有的元素的值都变成原来的2倍

  def list2(list_new): n = 0 for item in list_new: list_new[n] *= 2 n += 1 return list_new print(list2([2,3,4,5,6]))

  3、获取指定元素对应的下标

  def list_1(list:list, item): index_list = [] for index in range(len(list)): if list[index] == item: index_list.append(index) return index_list print(list_1([1,3,2,2,3,3],3)) 结果： 3 [4, 6, 8, 10, 12] 2 ```

  Read All

  ---

• 学生管理系统

  2018-08-28

  Python

  作业：学生管理系统

  ================================================= python1806学生管理系统 1.添加学生信息 2.查看学生信息 3.修改学生信息 4.删除学生信息 5.退出 ================================================= 1.在一个系统中可以保存多个学生信息 2.添加学生（输入姓名、年龄、电话）到1中的变量中 3.修改学生的电话（输入姓名，和电话） 4.删除学生（输入姓名，将其对应的信息从系统中删除） 5.退出系统

  name = ''   #存储用户信息
  age = ''
  tel = ''
  python1806 = []
  
  while True:
      print('=================================================')
      print('                  1.添加学生信息')
      print('                  2.查看学生信息')
      print('                  3.修改学生信息')
      print('                  4.删除学生信息')
      print('                  5.退出')
      print('=================================================')
      n = input('请输入你想执行的功能：')
      if n == '1':    #添加信息
          name = input('请添加学生姓名：')
          age = input('请添加学生年龄：')
          tel = input('请添加学生电话：')
          dict_new = {'name': name, 'age': age, 'tel': tel}
          python1806.append(dict_new)
          continue
      elif n == '2':    #查看信息
          for index in range(len(python1806)):
              print('姓名：%s ，年龄：%s ，电话：%s'%(python1806[index]['name']\
                                               ,python1806[index]['age'],\
                                           python1806[index]['tel']))
      elif n == '3':    #修改信息
          temp_index = []    #姓名相同时，临时存储姓名
          name_change = input('请输入你想要修改信息的学生姓名：')
          for index in range(len(python1806)):    #依次查找学生信息
              if python1806[index]['name'] == name_change:   #找到对应学生，修改信息
                  temp_index.append(index)  #姓名相同学生所对应的下标都存在temp_index表里面去
              elif index == len(python1806) - 1:  #没有查找到对应学生
                  if not temp_index:
                      print('你输入的学生不存在！！')
                      break
          count = []   #保存提示序号
          for x in range(len(temp_index)):   #给予用户相同姓名学生信息提示,进行选择修改
              print('%d、姓名：%s 年龄：%s 电话：%s'%(x,python1806[temp_index[x]]['name'],\
                                            python1806[temp_index[x]]['age'], \
                                            python1806[temp_index[x]]['tel']))
              count.append(x)
          if count:
              num = int(input('请输入你要修改的相同姓名学生编号：'))
          for i in range(len(count)):
              if num == i:
                  age_change = input('修改年龄为：')
                  tel_change = input('修改电话为：')
                  python1806[temp_index[count[i]]]['age'] = age_change
                  python1806[temp_index[count[i]]]['tel'] = tel_change
                  print('修改成功！')
              elif num < 0 or num >= len(count):
                  print('输入错误！')
                  break
          continue
      elif n == '4':    #删除信息
          temp_index = []  # 姓名相同时，临时存储姓名
          name_del = input('请输入你想要删除信息的学生姓名：')
          for index in range(len(python1806)):  # 依次查找学生信息
              if python1806[index]['name'] == name_del:  # 找到对应学生
                  temp_index.append(index)  # 姓名相同学生所对应的下标都存在temp_index表里面去
              elif index == len(python1806) - 1:  # 没有查找到对应学生
                  if not temp_index:
                      print('你输入的学生不存在！！')
                      break
          count = []  # 保存提示序号
          for x in range(len(temp_index)):  # 给予用户相同姓名学生信息提示,进行选择删除
              print('%d、姓名：%s 年龄：%s 电话：%s' % (x, python1806[temp_index[x]]['name'], \
                                              python1806[temp_index[x]]['age'], \
                                              python1806[temp_index[x]]['tel']))
              count.append(x)
          if count:
              num = int(input('请输入你要删除的相同姓名学生编号：'))
          for i in range(len(count)):
              if num == i:
                  del python1806[temp_index[count[i]]]
                  print('删除成功！')
              elif num < 0 or num >= len(count):
                  print('输入错误！')
                  break
          continue
      elif n == '5':   #退出
          exit('系统已退出...')
      else:    #输入不合法，提示重新输入
          print('输入错误，请按照提示输入！')
          while True:
              print('请选择：1（继续）、2（退出）：')
              n = input('请输入数字：')
              if n == '1':    #输入合法性判断
                  break
              elif n == '2':
                  exit('退出系统...')
              else:    #输入错误，提示重新输入
                  print('输入错误！请重新输入！')
                  continue
          continue
  

  Read All

  ---

• 容器02-字典和集合

  2018-08-28

  Python

  容器

  字典和集合

  一、字典–dict

  字典：容器类型，以键值对作为元素。（字典里面存的数据全是以键值对出现的）

  字典是可变的（增删改）— 指字典中的键值对的值和个数是可变的

  • 键值对 –> 键：值（key：value） {key1：value1，key2：value2，…} 注意： key–必须唯一，不可变的（数字、布尔、字符串、元组，推荐使用字符串） 值 – 没有要求

    1、声明字典

    dict1 = {1:100, 'a':97, True:'布尔', (10,11):'start'}

    2、获取字典的元素对应的值（字典存数据实质是存值，key是获取value的手段）

    person = {'name':'星辰','age':20}
    print(person['name'])
    

    通过 key 获取 value 时，如果key不存在会发生keyError异常

  - dict[‘key’] 和 dict.get(‘key’) 方法使用区别

  person = {'name':'星辰','age':20}
  print(person['name'])
  #下面两种方式结果相同
  print(person.get('age'))
  print(person['age'])     
  #下面两种方式结果不同
  print(person.get('sex'))     #如果key不存在返回None
  print(person['sex'])   #报错
  

  使用情况总结： 1、确定key肯定存在，用 dict[] 语法获取 value ； 2、key值可能不存在，不存在的时候不希望报错，而是对它进行特殊处理，使用dict.get(‘key’)方法

  3、遍历字典

  遍历字典直接取到的是字典所有 key 值

  person = {'name':'星辰','age':20}
  for key in person:
    print(key)
    print(person[key])
    print()
  
  name
  星辰
  
  age
  20
  

  4、改（修改key对应的value）

  语法：dict[key] = 新值

  5、增（添加键值对）

  增加语法和修改语法一样，如果存在即为修改，不存在即为增加。 语法：dict[key] = 值

  5、删（删除键值对）

  语法： （1）、del dict [key] （2）、dict.pop（key）— 与列表类似，将值取出来保存,不是键值对。

  6、运算符 – in 、not in

  不支持 ‘ + ‘ 和 ‘ * ‘ 操作 查找 值 在不在字典中

  7、一些关于字典的方法

  说明：

  • dict.copy()：拷贝字典中所有元素，放在一个新的字典中（浅拷贝–见Day6）。
  • dict.fromkeys(序列，默认值=None)： 将序列中的每个值作为key，默认值为value创建一个新的字典 ``` dict = {} dict = dict.fromkeys(‘abcd’,111) print(dict)

  {‘a’: 111, ‘b’: 111, ‘c’: 111, ‘d’: 111}

  - dict.setdefault(key,default=None)：添加键值对，默认为None，不能修改。
  - dict1.update(dict2)：将dict2的键值对更新（添加）到dict1中：（1）如果dict2中的key在dict1中存在，就用key2对应的值更新key1的值（2）不存在就添加。
  ##### 8、字典和列表的组合使用--重点
  **列表和字典选择：
  列表--保存数据是一个类型。
  字典--保存数据类型不同。**
  
  **应用：学生管理系统**
  a、一个系统可以存储多个学生
  b、一个学生可以存储：姓名，电话，籍贯，专业等
  c、添加、删除、修改学生信息
  

  #1、列表中有字典 student_system = [ {‘name’:’stu1’, ‘age’:18, ‘tel’:110}, {‘name’:’stu2’, ‘age’:19, ‘tel’:120}, {‘name’:’stu3’, ‘age’:20, ‘tel’:130}] #取出第一个学生的籍贯 print(student_system[0][‘name’])

  #2、字典中有列表 py_class = { ‘class_name’:’python1806’, ‘student’:[{‘name’:’stu1’, ‘age’:18, ‘tel’:110}, {‘name’:’stu2’, ‘age’:19, ‘tel’:120}, {‘name’:’stu3’, ‘age’:20, ‘tel’:130} ], } #取班级名 print(py_class[‘class_name’]) #取第三个学生的名字 print(py_class[‘student’][2][‘name’])

  python1806 stu3

  扩展：
  

  练习1：在班级python1806添加一个学生，要学生自己输入信息：名字，年龄，id

  name = input(‘请输入您的名字：’) age = int(input(‘输入您的年龄：’)) id = input(‘请输入您的id：’) student = {‘name’:name, ‘age’:age, ‘id’:id} class_python1806 = [{‘name’:’stu1’, ‘age’:18, ‘tel’:110}, {‘name’:’stu2’, ‘age’:19, ‘tel’:120}, {‘name’:’stu3’, ‘age’:20, ‘tel’:130} ] class_python1806.append(student) print(class_python1806)

  #练习2：输入一个学生的姓名，根据姓名取删除对应的学生 name_del = input(‘输入您要删除的学生姓名：’) for i in range(len(class_python1806)): if class_python1806[i][‘name’] == name_del: del class_python1806[i] print(class_python1806)

  结果： 请输入您的名字：111 输入您的年龄：11 请输入您的id：11 [{‘name’: ‘stu1’, ‘age’: 18, ‘tel’: 110}, {‘name’: ‘stu2’, ‘age’: 19, ‘tel’: 120}, {‘name’: ‘stu3’, ‘age’: 20, ‘tel’: 130}, {‘name’: ‘111’, ‘age’: 11, ‘id’: ‘11’}] 输入您要删除的学生姓名：111 [{‘name’: ‘stu1’, ‘age’: 18, ‘tel’: 110}, {‘name’: ‘stu2’, ‘age’: 19, ‘tel’: 120}, {‘name’: ‘stu3’, ‘age’: 20, ‘tel’: 130}]

  
  ### 二、集合 -- set
  集合是python中的一种容器类型：无序的，可变的，值唯一
  ##### 1、声明一个集合
  set1 = {1, 'abc'}
  将其他序列转换为集合，自动去重
  ```set2 = set('name name') --> {'n', 'a', ' ', 'e', 'm'}```
  一般容器类型都不能放入集合，比如列表，字典等
  ##### 2、查（获取集合中的元素）
  **集合是不能直接单独获取其中某一个元素的。
  只能遍历获取每一个元素**
  ##### 3、增
  a、set.add(元素)
  b、set1.update(set2)  -- 将set2元素添加到set1中
  ##### 4、删
  set.remove(元素)
  set.clear()  ---  全删
  ##### 5、数学相关的集合运算 --- 重点
  - 判断包含情况：
  集合1 >= 集合2：判断集合1中是否包含集合2
  - 求并集：|
  

  set1 = {1, 2, 3, 4, 5, 6} set2 = {1, 2, 3, 8, 9} print(set1 | set2)

  {1, 2, 3, 4, 5, 6, 8, 9}

  - 求交集：&
  

  set1 = {1, 2, 3, 4, 5, 6} set2 = {1, 2, 3, 8, 9} print(set1 & set2)

  {1, 2, 3}

  - 求差集：-
  

  set1 = {1, 2, 3, 4, 5, 6} set2 = {1, 2, 3, 8, 9} print(set1 & set2)

  {4, 5, 6}

  - 求补集：^
  

  set1 = {1, 2, 3, 4, 5, 6} set2 = {1, 2, 3, 8, 9} print(set1 ^ set2)

  {4, 5, 6, 8, 9}

  补充：
  

  sum（）：python中对序列求和的方法 dir（）：可以查找一些内置函数 isinstance(a, b)：比较a、b类型是否相同，返回True和False isinstance(a, 类型)：判断a是否为一个类型 str.split():把字符串以空格分开，返回一个列表 re.sub(‘[要替换的字符]’, ‘新字符’,字符串) ```

  Read All

  ---

• 容器01-列表和元组

  2018-08-27

  Python

  容器

  一、列表–list

  • 列表示python中的容器类型。有序的，可变的容器（可变指列表中的元素、位置、个数可变）
  • 元素：指的是列表中的每一个内容。列表中的元素可以是任意类型的元素

  1、声明列表 （1）、直接声明列表 scores = [90, 80, 75] # [] –> 代表空列表 （2）、将其它的数据类型转换成列表（只有序列才能转换:字符串和range（）、字典、元组、集合、生成式、迭代器） chars = list（'abcdef'） 2、获取列表元素–列表[下标] tv_name = ['行尸走肉', '冰与火之歌：权利的游戏'] 3、获取部分元素（切片）：列表[下标1：下标2：步进] # 切片的结果是列表–效果和字符串切片相同 # 步进为正，从前往后取值；步进为负，从后往前取值。 4、遍历（一次获取每个元素）

  #统计80分以上的个数
  grade = [67, 84, 93, 74, 95, 83]
  count = 0
  for item in grade:
      if item >= 80 :
          count += 1
  print('80分以上的同学有：%d'%count)
  
  80分以上的同学有：4
  

  改 –> 修改列表

  语法：列表名[下标] = 新值 （通过下标获取元素）

  增 –> 增加元素

  a: list.append（元素） #添加到list的后面

  scores = []
  for _ in range (5):
      score = input('请输入学生成绩：')
      scores.append(int(score))
  print(scores)
  

  b: list.insert（下标，元素） # 在指定的下标前插入一个元素

  删 –> 删除元素

  a:del 列表[下标] –> 根据下标去删除列表中的元素

  del 语句是python中删除数据的语法，它可以删除任何数据：del 变量（删除变量） del 列表（删除列表）

  b:list.pop（下标）–> 将列表中的指定下标对应的元素取出来 list.pop() –> 将列表最后一个元素取出来

  food = foods.pop(1)   #将foods中删除值取出来保存在food中
  

  练习：将一个保存成绩的列表中，成绩低于60分的全部删除
  [78, 59, 40, 90, 89, 45, 69, 30] -->[78, 90, 89, 69]
  a = [78, 59, 40, 90, 89, 45, 69, 30]
  for i in a[:]:   
      if i < 60:
          a.remove(i)
  print(a)
  

  我们遍历列表的元素，我们一般遍历它的拷贝的值( [:] )

  c: list.remove（元素） –> 删除列表中的值 如果这个值在列表中有多个，只删除第一个值。

  a = ['香蕉'， '饼干']
  a.remove('饼干')
  

  注意：python中，变量在存数据的时候，会根据数据类型的不同，使用两种方式来存值

  • 值类型：变量存数据直接存值。例如：整型、浮点型、布尔、字符串
  • 引用类型：变量存数据的时候，存的是数据在内存中的地址。例如：列表、字典、元组、集合、函数、自定义的类的对象等。

    列表之间的运算

    A、 + 操作

    列表1 + 列表2：将列表1中的元素和列表2的元素依次合并，产生一个新的列表。

    B、 * 操作

    列表 * N：将列表中的元素重复N次，产生一个新的列表。

    C、 in 操作

    元素 in 列表：判断一个元素是否在列表中。 说明：

  • append（）和extend（）方法区别： append（）是将一个列表作为一个元素加在另一个列表后面。 extend（）是将元素一个一个加在另一个列表后面。
  • copy（）方法：将列表的元素全部拷贝一份产生一个新的列表，相当于列表[:] 注意：这儿拷贝是浅拷贝 浅拷贝：只是单纯将值拷贝，如果是对象就拷贝相应的地址 深拷贝：拷贝元素的值，如果是对象，先根据地址找到值，拷贝值出来，存在一个新的地址里面

    #浅拷贝：改变number1值，会影响new_numbers的值
    numbers1 = [1, 2]
    numbers = [numbers1,3, 4,100]
    new_numbers = numbers.copy()
    #深拷贝：改变number1值，不会影响new_numbers的值
    import copy
    new_numbers2 = copy.deepcopy(numbers)
    

    二、元组–tuple

    元组就是不可变的列表。列表中除了和可变相关的内容以外，都使用于元组。 不支持增、删除、修改，只支持和查相关的操作。 tuple1 = （1, 2，'abc', True） t2 = (100) –> type( t2 ) 是int型 # t2 = (100,) –> type( t2 ) 是tuple型 t2 = 1,2,3,4 –> type( t2 ) 是tuple型 t2 = () –> 空元组

  特殊操作一：

  point = (100,200)
  print(point[0], point[1])
  #通过两个变量来获取元组中唯一的两个元素的值
  x, y = point
  
  100 200
  

  特殊操作二：

  • 通过在变量前加 * ，获取元组、列表的一部分元素值，结果是列表 ``` user = (‘小刘’,80,90,78,’男’) name, *score,sex = user print(name, score,sex)

  小刘 [80, 90, 78] 男 ```

  Read All

  ---

• 容器01-列表和元组

  2018-08-27

  Python

  容器

  一、列表–list

  • 列表示python中的容器类型。有序的，可变的容器（可变指列表中的元素、位置、个数可变）
  • 元素：指的是列表中的每一个内容。列表中的元素可以是任意类型的元素

  1、声明列表 （1）、直接声明列表 scores = [90, 80, 75] # [] –> 代表空列表 （2）、将其它的数据类型转换成列表（只有序列才能转换:字符串和range（）、字典、元组、集合、生成式、迭代器） chars = list（'abcdef'） 2、获取列表元素–列表[下标] tv_name = ['行尸走肉', '冰与火之歌：权利的游戏'] 3、获取部分元素（切片）：列表[下标1：下标2：步进] # 切片的结果是列表–效果和字符串切片相同 # 步进为正，从前往后取值；步进为负，从后往前取值。 4、遍历（一次获取每个元素）

  #统计80分以上的个数
  grade = [67, 84, 93, 74, 95, 83]
  count = 0
  for item in grade:
      if item >= 80 :
          count += 1
  print('80分以上的同学有：%d'%count)
  
  80分以上的同学有：4
  

  改 –> 修改列表

  语法：列表名[下标] = 新值 （通过下标获取元素）

  增 –> 增加元素

  a: list.append（元素） #添加到list的后面

  scores = []
  for _ in range (5):
      score = input('请输入学生成绩：')
      scores.append(int(score))
  print(scores)
  

  b: list.insert（下标，元素） # 在指定的下标前插入一个元素

  删 –> 删除元素

  a:del 列表[下标] –> 根据下标去删除列表中的元素

  del 语句是python中删除数据的语法，它可以删除任何数据：del 变量（删除变量） del 列表（删除列表）

  b:list.pop（下标）–> 将列表中的指定下标对应的元素取出来 list.pop() –> 将列表最后一个元素取出来

  food = foods.pop(1)   #将foods中删除值取出来保存在food中
  

  练习：将一个保存成绩的列表中，成绩低于60分的全部删除
  [78, 59, 40, 90, 89, 45, 69, 30] -->[78, 90, 89, 69]
  a = [78, 59, 40, 90, 89, 45, 69, 30]
  for i in a[:]:   
      if i < 60:
          a.remove(i)
  print(a)
  

  我们遍历列表的元素，我们一般遍历它的拷贝的值( [:] )

  c: list.remove（元素） –> 删除列表中的值 如果这个值在列表中有多个，只删除第一个值。

  a = ['香蕉'， '饼干']
  a.remove('饼干')
  

  注意：python中，变量在存数据的时候，会根据数据类型的不同，使用两种方式来存值

  • 值类型：变量存数据直接存值。例如：整型、浮点型、布尔、字符串
  • 引用类型：变量存数据的时候，存的是数据在内存中的地址。例如：列表、字典、元组、集合、函数、自定义的类的对象等。

    列表之间的运算

    A、 + 操作

    列表1 + 列表2：将列表1中的元素和列表2的元素依次合并，产生一个新的列表。

    B、 * 操作

    列表 * N：将列表中的元素重复N次，产生一个新的列表。

    C、 in 操作

    元素 in 列表：判断一个元素是否在列表中。 说明：

  • append（）和extend（）方法区别： append（）是将一个列表作为一个元素加在另一个列表后面。 extend（）是将元素一个一个加在另一个列表后面。
  • copy（）方法：将列表的元素全部拷贝一份产生一个新的列表，相当于列表[:] 注意：这儿拷贝是浅拷贝 浅拷贝：只是单纯将值拷贝，如果是对象就拷贝相应的地址 深拷贝：拷贝元素的值，如果是对象，先根据地址找到值，拷贝值出来，存在一个新的地址里面

    #浅拷贝：改变number1值，会影响new_numbers的值
    numbers1 = [1, 2]
    numbers = [numbers1,3, 4,100]
    new_numbers = numbers.copy()
    #深拷贝：改变number1值，不会影响new_numbers的值
    import copy
    new_numbers2 = copy.deepcopy(numbers)
    

    二、元组–tuple

    元组就是不可变的列表。列表中除了和可变相关的内容以外，都使用于元组。 不支持增、删除、修改，只支持和查相关的操作。 tuple1 = （1, 2，'abc', True） t2 = (100) –> type( t2 ) 是int型 # t2 = (100,) –> type( t2 ) 是tuple型 t2 = 1,2,3,4 –> type( t2 ) 是tuple型 t2 = () –> 空元组

  特殊操作一：

  point = (100,200)
  print(point[0], point[1])
  #通过两个变量来获取元组中唯一的两个元素的值
  x, y = point
  
  100 200
  

  特殊操作二：

  • 通过在变量前加 * ，获取元组、列表的一部分元素值，结果是列表 ``` user = (‘小刘’,80,90,78,’男’) name, *score,sex = user print(name, score,sex)

  小刘 [80, 90, 78] 男 ```

  Read All

  ---