4-python-bas

Python 基础

1. 列表方法

   fruits = ['orange', 'apple', 'pear', 'banana']
   
   # 增加元素（从后面加入）
   # fruits.append('kiwi')
   # 增加集合
   # fruits.extend(['kiwi','water'])
   # 合并两个列表（可以在前面加，也可以在后面加）
   # new_fruits=fruits+['kiwi','water']
   # new_fruits=['kiwi','water']+fruits
   # 插入元素（第一个是索引，这种方法开销很大，插入后若空间不够要移到其它空间）
   # fruits.insert(0,'pick');
   
   # 删除元素（若apple没有会报错）
   # fruits.remove('apple')
   # del fruits[1]
   # fruits[2:4]=[]
   # 删除列表末尾的元素
   # fruit表s.pop()
   
   # 替换元素
   # fruits[0:3]=['橙子','苹果','梨']
   
   # 清空元素
   # fruits.clear()
   # del fruits[:]  #不同于del fruits
   # fruits[ : ]=[]
   
   # 判断是否存在
   # print('apple' in fruits)
   
   # 最大最小值
   # print(max(fruits))
   # print(min(fruits))
   

2. 栈和队列

   # -*- coding: UTF-8 -*-
   from collections import deque
   fruits = ['orange', 'apple', 'pear', 'banana']
   from collections import deque
   queue = deque(fruits)
   
   # 先进先出：队列
   queue.append('haha')
   queue.popleft()
   
   # 先进后出
   queue.append('')
   queue.pop()
   
   print(list(queue))
   

   模糊查询图书demo

   books=['三国演义','西游记','三国志','三国杀','水浒传']
   result_book = []
   display=','.join(books)
   print(display)
   while True:
       con = input('请搜索\n')
       if con=='exit':
           break
       else:
           result_book.clear()
           for book in books:
               if con in book:
                   result_book.append(book)
           print(result_book)
   

   二维数组：图书按价格排序demo

   books=[
       ['三国演义','罗贯中',160,'三国出版社',120],
       ['西游记','吴承恩',80,'西天出版社',10],
       ['三国志','陈寿',130,'三国出版社',20],
       ['三国杀','腾讯',500,'企鹅出版社',120],
       ['王者荣耀','腾讯',200,'企鹅出版社',20],
       ['水浒传','施耐庵',100,'梁山出版社',10]
   ]
   arr=[]                               #用于存放价格排序和索引
   for i in range(len(books)):
       li=[books[i][2],i]
       arr.append(li)
   arr.sort()
   print(arr)
   result_list=[]
   for item in arr:                     #item->[80,1]
       i=item[1]
       result_list.append(books[i])
   print(result_list)
   

3. 列表初始化

   squares=[]
   squares=[x**2 for x in range(10)]
   vec = [-4, -2, 0, 2, 4]
   vec2=[x*2 for x in vec]
   vec3=[x for x in vec if x >= 0]
   vec4=[abs(x) for x in vec]
   
   print ([(x, x**2) for x in range(6)])
   

   补充：map()

   map() 会根据提供的函数对指定序列做映射。

   第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

   arr=[1,2,3,4]
   mm=map(lambda x:x ** 2,arr)
   print(next(mm))
   for res in mm:
       print(res)
   

   去掉列表元素单词左右空格

   freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
   # 去掉单词左右空格
   freshfruit=[weapon.strip() for weapon in freshfruit]
   

4. 排序

   • 冒泡法

   list01=[6,9,3,4,2,7,5]
   i=0
   length=len(list01)
   while i<length-1:                    #剩一个的时候不用再来一轮，所以是长度减一
       j=0
       while j<length-1-i:              #每一次都把最大值放在最后，所以在下一轮去掉已经在后面排好的数据个数
           if list01[j]>list01[j+1]:    #每一个数据和下一个比较
               t=list01[j]
               list01[j]=list01[j+1]
               list01[j+1]=t
           j=j+1
       i=i+1
   print(list01)
   

   • 选择法

   list02=[2,1,7,4,3,9,5]
   length=len(list02)
   i=0
   while i<length-1:         #除去最后一个
       j=i+1                 #与下一个比较
       min_position=i        #用于记录最小值的位置
       while j<length:
           if list02[min_position]>list02[j]:
               min_position=j#如果找到较小值就记下位置
           j=j+1
       t=list02[i]
       list02[i]=list02[min_position]
       list02[min_position]=t
       i=i+1
   print(list02)
   

5. 元祖-Tuple

   1. 特性

      和字符串一样，tuple一旦创建就不能改变，可以切片。

      t1=(10)
      print(type(t1)) #<class 'int'>
      t2=(10,)
      print(type(t2)) #<class 'tuple'>
      

      tt=('python',['2.6','3.7'],'it')
      
      print(tt[1])
      
      tt[0]='java' #error
      
      tt[1][0]='2.5' #不会出错，因为引用没有改变
      

      任意无符号的对象，以逗号隔开，默认为元组

      x,y=1,2
      tup3 = "a", "b", "c", "d"
      

   2. 访问

      t2=(10,20,30,40)
      print(t2[0:2])
      

   3. 修改

      修改元组是非法的，元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

   4. 删除

      del t2
      

   5. 元组运算符

      与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

      Python	表达式	结果 描述
      len((1, 2, 3))	3	计算元素个数
      (1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
      (‘Hi!’,) * 4	(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)	复制
      3 in (1, 2, 3)	True	元素是否存在
      for x in (1, 2, 3): print (x,)	1 2 3	迭代

   6. index() count()

      index找不到会报错，慎用，最好用in方法

   7. 和list比较

      ①、Tuple 与 list 的相同之处

      定义 tuple 与定义 list 的方式相同, 除了整个元素集是用小括号包围的而不是方括号。
      Tuple 的元素与 list 一样按定义的次序进行排序。 Tuples 的索引与 list 一样从 0 开始, 所以一个非空 tuple 的第一个元素总是 t[0]。
      负数索引与 list 一样从 tuple 的尾部开始计数。
      与 list 一样分片 (slice) 也可以使用。注意当分割一个 list 时, 会得到一个新的 list ；当分割一个 tuple 时, 会得到一个新的 tuple。

      ②、Tuple 不存在的方法

      您不能向 tuple 增加元素。Tuple 没有 append 或 extend 方法。
      您不能从 tuple 删除元素。Tuple 没有 remove 或 pop 方法。
      然而, 您可以使用 in 来查看一个元素是否存在于 tuple 中。

      ③、用 Tuple 的好处

      Tuple 比 list 操作速度快。如果您定义了一个值的常量集，并且唯一要用它做的是不断地遍历它，请使用 tuple 代替 list。
      如果对不需要修改的数据进行 “写保护”，可以使代码更安全。使用 tuple 而不是 list 如同拥有一个隐含的 assert 语句，说明这一数据是常量。如果必须要改变这些值，则需要执行 tuple 到 list 的转换。

      ④、Tuple 与 list 的转换

      Tuple 可以转换成 list，反之亦然。内置的 tuple 函数接收一个 list，并返回一个有着相同元素的 tuple。而 list 函数接收一个 tuple 返回一个 list。从效果上看，tuple 冻结一个 list，而 list 解冻一个 tuple。

      list_tu=list(tu)
      list_tu[2]=90
      tu=tuple(list_tu)
      print(tu)
      

      tuple和string的相互转化

      s='hello'
      tu01=tuple(s)         #('h', 'e', 'l', 'l', 'o')
      print(''.join(tu01))  #hello