users.pop[1] #列表删除特有


字符串本身不能修改删除//不可变类型。

不能用del删除字符串。

5. 修改(数字/布尔/字符串除外)

```python
users=['a','b',99]
users[2] = 66 #可以修改
users[0] = 'a' #可以修改
users[0][0] #不能修改
  1. 步长,默认步长为1,当步长为负数时从后往前取

    name='alexalex'
    val=name[0:-1:2] # 0为起始位置,-1结束位置,2为步长
    print(name)
    aeae
    -------------------
    val=name[::2] #从前到后步长为2
    -------------------
    val=name[-1:0:-2] #从后往前取,步长为2,答案是xlxl
    val=name[::-2] #从后往前取,步长为2,答案是xlxl
    -------------------
    val=name[::-1] #反转,输入xela
    
  2. for循环

    name='alex'
    for item in name : #遍历name将每个字符传递给item并打印
        print(item)
    

    打印1到10

    for i in range(1,11):  #前取后不取
    	print(i)
    

    打印1到10不打印7

    for i in rang(1,11):  
    	if i==7:
    		continue
    	print(i)
    

列表

  1. len

    users=["a","b","c"]
    val=len(users)
    print(val) #3
    
  2. 索引

    users=["a","b","c"]
    val = users[0]
    print(val) #a
    
  3. 切片

    users=["a","b","c"]
    val = users[0:2] #['a', 'b']
    
  4. 步长

    users=["a","b","c"]
    val = users[0:2:2] #['a']
    
  5. 将输入的字符存入列表里使用.append()

    .append()是在列表的最后追加一个元素

    users=[]
    while True :
        name = input('输入姓名:')
        users.append(name)
        print(users)
    -------------------------------
    users=[]
    users.append('alex')
    print(users)
    
  6. 插入.insert(n,'xxx'),在第n个元素前插入xxx

    users=['a','b','c']
    users.insert(0,'d')
    print('users')
    
  7. 删除.remove(xxx)如果有两个相同的,只删除第一个

    users.remove('a') #删除users里的a
    

    .pop(n)n 是索引位置,如果不加索引位置,默认删除最后一个

    delete = users.pop(0)可以将删除的数据存储在delete中,而del仅仅是删除

    users.pop(0) #删除第0个
    

    clear 清空

    users.clear() #清空列表
    
  8. 列表的嵌套

    users=['a',1,True,[12,2,'b'],[3,['alex','d'],6]]
    users=[3][2] #取2
    users=[4][1][0] # 取'alex'
    

    .extend()习题:将字符出s='abc'添加到列表users中,不使用循环,()可以放元组,字符出,列表

    users.extend(s)
    
  9. 反转 v1.reverse()

  10. 从小到大排 v1.sort(reverse=False)

    从大到小排v1.sort(serverse=True)

  11. 判断敏感词

    v = ['alex','我','你是谁']
    if '我' in v :
        print ('包含敏感词')
    

元组

  1. 元组的书写规范

    users=[1,2,3,4,5,6] #列表(可变类型)
    users=(1,2,3,4,5,6) #元组(不可变类型)
    
  2. 没有独有功能,只有公共功能

    公共:

    1. 索引

      users=(1,2,3,"a")
      print(users[3])
      
    2. 切片

      users=(1,2,3,"a")
      print(users[0:2])
      
    3. 步长

      users=(1,2,3,"a")
      print(users[0:2:2])
      
    4. 删除(不能删除)

    5. 修改(不能修改)

    6. for循环

      users=(1,2,3,"a")
      for i in users:
          print(i)
      
    7. len

      users=(1,2,3,"a")
      print(len(users))
      
  3. 特殊:元组中的元素不能被删除/修改

    v1 = (11,22,33)
    v1[1] = 999 #错误
    v1 = 999 # 可以
    ----------------------
    v1 = v1 = (11,22,33,(44,55,66)) # 可以嵌套
    ----------------------
    v2 = [11,22,33,(44,55,66)]
    v2[-1][1] = 99 # 错误 ,(44,55,66)里面不能修改,整体可以,因为是列表里的元素
    v2[-1] = 123 # 正确
    ----------------------
    v3 = (11,[1,2,3],22,33) #其中的[1,2,3]是元组的元素
    v3[1] = 666 # 错误,[1,2,3]是元组的元素,不能修改
    v3[1][2] = 123 # 可以
    
  4. 判断敏感词用 in 同字符串和列表一样

字典

帮助用户表示一个事物的信息(事物有多个属性)

data = {键:值,键:值,键:值}
  1. 获取值

    info = {"name":'郭希文','age':21,'gender':'男'} #键值对
    print(info['name'])#取值
    
  2. 取值,用这个也可以判断字典里是否有这个数据

    info = {'k1':'v1','k2':'v2'}
    n = info.get('k111',666) #'k111'是键,当能取到值时取值,当取不到时返回666,如果没设置默认返回None
    
  3. .values()取值

  4. 输出所有的键/值

    info = {"name":'郭希文','age':21,'gender':'男'}
    for i in info.keys():
        print(i)
    -----------------------------------
    info = {"name":'郭希文','age':21,'gender':'男'}
    # for a,b in info.items():
    #	print(a,b) #输出所有的键值
    for i in info.items() :
        print(i) #输出所有的键值
    
  5. 输出所有键和值,并让用户输入键,根据用户输入,输出对应的值

    info = {"name":'郭希文','age':21,'gender':'男'}
    for k,v in infor.items():
        print(k,v)
    key = input('请输入键:') #'name'
    print(info[key])  #info['name']
    
  6. 给一个空字典,请在空字典中添加数据:k1:1,k2:2,k3:3

    info = {}
    info['k1'] = '1'
    info['k2'] = 2
    info['k3'] = 3
    print(info)
    
  7. 给一个空字典,请让用户输入:key,value,将输入的key,value添加到字典里

    info = {}
    k = input('请输入key:')
    v = input('请输入value:')
    info[k] = v
    print(info)
    
  8. 给一个空字典,请让用户一直输入:key,value,将输入的key,value添加到字典里,直到用户输入了N,则表示不在输入

    info = {}
    while True :
        k = input('请输入key:')
        if k == 'N' :
            break
        v = input('请输入value:')
        info[k] = v
    print(info)
    
  9. 给一个字符串,message = "k1|v1,k2|v2,k3|123",转换成字典

    info = {}
    message = "k1|v1,k2|v2,k3|123"
    for item in message.split(','):
    	v1,v2 = item.split('|')
        info[v1] = v2
    print(info)
    
  10. 数据类型嵌套,int/bool/str/list/tuple/dict

列表里边嵌套字典

字典嵌套,列表不能当键,字典不能当键#不可哈希

info = {'k1':'v1','k2':True,'k3':1,'k4':(11,22),'k5':[33,44],'k6':{'kk':'vv'},1:{'kk':'vv'},False:{'kk':'vv'},(11,2):{'kk':'vv'}} 
  1. 习题创建一个用户列表,列表里放字典,首先用户输入用户名密码注册,在进行登录

    users_list = []
    while True:
        count = 0
        info = {'username':'','password':''}
        name = input('请输入账号:')
        if name == 'N':
            break
        pwd = input('请输入密码:')
        info['username'] = name
        info['password'] = pwd
        users_list.insert(count,info)
        count += 1
    print(users_list)
    print('注册成功')
    ---------------------------------------------
    k = input('请输入用户名:')
    v = input('请输入密码:')
    num = len(users_list)
    for i in users_list:
        num -= 1
        k1 = i['username']
        v2 = i['password']
        if k == k1 and v == v2 :
            print('登录成功')
            num = 1
            break
        else :
            continue
    if num == 0 :
        print('登录失败')
    
  2. 删除

    info = {'k1':'v1','k2':'v2'}
    result = info.pop('k2')
    print(info,result) #结果为{'k1':'v1'} v2
    
    del info['k1'] #也是删除
    
  3. 更新

    info.updata({'k3':'v3'}) #如果不存在就添加,如果键存在就更新
    
  4. 判断k1是否在其中?

    if 'k1' in v : #默认判断的是 键
    

    判断v2是否在其中?

    方式一:

    flag = '不存在'
    for v in v.values():
        if v == 'v2':
            flag = '存在'
    print(flag)
    

    方式二:

    if 'v2' in list(v.values()): #将值的整体强制转换为列表,再进行判断
        pass
    

    判断k2:v2是否在其中?

    value = v.get('k2')
    if value == 'v2':
        print ('存在')
    else:
        print ('不存在')
    
  5. 有序:元组,列表

    无序:字典(3.6之后是有序的)

集合 set : v = {1,2,3,4}

无序,不重复的/不能通过索引删除

#v1 = set () 表示空集合

  1. 添加

    v = {1,2}
    v.add('a')
    
  2. 删除

    v = {1,2,'a'}
    v.discard('a')
    
  3. updata,批量添加

    v = {1,2,'a'}
    v.updata({11,22,33})
    
  4. 交集

    v = {1,2,'a'}
    result = v.intersection({1,'a'}) #不对集合本身做操作,需要赋值
    print(result)
    
  5. 并集

    v = {1,2,'a'}
    result = v.union({1,'a','b'})
    print(result)
    
  6. 差集

    v = {1,2,'a'}
    result = v.difference({1,'a','b'}) #输出结果是,v中而{1,'a','b'}没有的
    print(result)
    
  7. 对称差集

    v = {1,2,'a'}
    result = v.symmetric_difference({1,'a','b'})
    print(result)
    
  8. len()

  9. for 循环

  10. 集合嵌套

    1. info = {1,2,3,True,'国风',None,(4,5)} #列表,字典,集合不能放在集合中,不能作为字典的 键

深浅拷贝

  1. 浅拷贝:拷贝第一次

  2. 深拷贝:拷贝所有数据(可变),有时候由于小数据池使得不可变数据地址一样

  3. import copy
    

文件操作

  1. file_object = open('log.txt',mode = 'r+',encoding='utf-8') #r+可读可写,r可读,w可写
    content = file_object.read()
    file_object.write('我')
    
  2. file_object = open('log.txt',mode='w+',encoding='utf-8') #w,w+ ,会将文件清空,读取时需要调整光标
    data = file_object.read()#读不到
    print(data)
    file_object.write('alex')
    file_object.seek(0) #将光标移到第一个
    data = file_object.read()
    print(data)
    file_object.close()
    
  3. 可读可写 'a+',只要写光标会自动跳到最后

    file_object = open('log.txt',mode = 'a+',encoding='utf-8')#光标默认在最后,读文件是从光标开始读
    file_object.seek(0)
    data = file_object.read()
    print()
    file_object.close()
    
  4. r,只能读 **

  5. w,只能写,写之前清空 **

  6. a,只能追加 *

  7. r+

    1. 读:默认从0的光标开始读,也可以通过seek调整光标位置
    2. 写:从光标所在的位置开始写,也可以通过seek调整光标的位置

    w+

    1. 读:默认光标永远在写入的最后或0,也可以通过seek调整光标位置
    2. 写:先清空

    a+

    1. 读:默认光标在最后,也可以通过seek调整光标位置,然后再去读取
    2. 写:永远写在最后
  8. #写入实例:一般用于图片/音频/视频/未知代码
    f = open('a.txt',mode='wb')
    #把要写入的字符串转换成二进制
    data = '我好困'
    content = data.encode('utf-8') #将字符串按 utf-8编码转换成二进制
    #再将二进制写入文件中
    f.write(content)
    f.close()
    
  9. f = open('a.txt',mode='rb')
    #直接读取二进制
    data = f.read
    f.close()
    print(data)
    

三目运算

如果a>b的结果为真,h="变量1",如果为假,h="变量2"

h = "变量1" if a>b else "变量2"

函数

  1. 局部变量

    1. 在函数定义内声明变量的时候,它们与函数外具有相同名称的其他变量没有任何关系,即变量名称对于函数来说是 局部 的。这称为变量的 作用域 。所有变量的作用域是它们被定义的块,从它们的名称被定义的那点开始。

      #局部变量
      def func(x):
          print('x is', x)
          x = 2
          print('Changed local x to', x)
      print('局部变量')
      x = 50
      func(x)
      print('x is still', x)
      

      在上面这段代码中,首先函数定义了形参x,相当于函数的局部变量。在函数调用的时候,传入了外部x,外部x值为50。在函数内部将x值改为2,改变的是局部变量x,外部x不受影响,从最后的输出结果可以验证。运行结果如下:

      局部变量
      x is 50
      Changed local x to 2
      x is still 50
      
    2. 如果你想要为一个定义在函数外的变量赋值,那么你就得告诉Python这个变量名不是局部的,而是 全局 的。我们使用global语句完成这一功能。没有global语句,是不可能为定义在函数外的变量赋值的。例如:

      #访问外部变量
      def func2():
          global x
      
          print('x is', x)
          x = 2 #这个x是全局变量
          print('Changed local x to', x)
      print('访问外部变量')
      x = 50
      func2()
      print('Value of x is', x)
      

      运行结果如下:

      访问外部变量
      x is 50
      Changed local x to 2
      Value of x is 2
      
  2. 默认参数值

    只有在形参表末尾的那些参数可以有默认参数值,即你不能在声明函数形参的时候,先声明有默认值的形参而后声明没有默认值的形参。这是因为赋给形参的值是根据位置而赋值的。例如

    def func(a, b=5)
    
  3. 函数可以当作参数进行传递

    def func (arg):
        arg()
    def show ():
        print 999
    
    func(show)
    
  4. lambda表达式

    lambda表达式,为了解决简单函数的情况

    def func(a1,a2):
        return a1+100
    
    func = lambda a1,a2:a1+100
    #这两个是相同的效果
    
    func1 = lambda:100 # 没有参数,返回100
    
    func2 = lambda x1:x1*10
    
    func3 = lambda *args ,**kwargs : 100
    
    func4 = lambda n1,n2 : n1 if n1 > n2 else n2 #判断大小
    
  5. 内置函数

    1. 自定义函数

    2. 内置函数

      1. len

      2. open

      3. print

      4. range

      5. max()

      6. min()

      7. sum()

      8. abs() #计算绝对值

      9. pow()

        v = pow(2,3)
        print(v)# 2**3 2的3次方
        
      10. divmod() #计算出商和余数

      11. round()

        v = round (1.123,2) #保留小数点后2位,2可有可无
        print (v) #1.12 有默认四舍五入
        
      12. dict()

      13. list()

      14. tuple()

      15. int()

      16. str()

      17. bool()

  6. 进制转换

    1. bin () 将10进制转化成2进制

    2. oct() 将10进制转换成8进制

    3. hex() 将10进制转换成16进制

    4. int() 将其他进制转换成10进制

      v1 = '0b1101'
      result = int(v1,base=2)#指定读的是二进制
      print(result) #二进制转换成10进制
      
    5. 其他

      1. len()
      2. range()
      3. id()
      4. type()
      5. open()
    6. 编码相关

      1. chr(),将十进制数字准换成unicode编码中对应的字符串

      2. ord(),将unicode编码转换成十进制

      3. 生成随机数

        import random
        def ger_random_code(length=6):
            data = []
            for i in range(length):
                v = random.randint(65,90)
                data.append(chr(v))
            return ''.join(data)
        code = ger_random_code()
        print(code)
        
    7. 高级内置函数

      1. map()循环每个元素(第二个参数),然后让每个元素执行函数(第一个参数),将每个函数执行的结果保存到新的列表中,并返回。

        map(x,y) #第一个参数:必须是一个函数,第二个参数:必须是可迭代的类型

        v1 = [11,22,33]
        result = map (lambda x:x+100,v1)
        print(result) #在python2中会返回[111,122,133]
        print(list(result)) #python3中需要使用list转换后才能显示
        
      2. filter()过滤

        v1 = [11,22,'a',34]
        result = filter(lambda x:True if tpye(x) == int else False,v1)#使用lambda来代替func函数
        result = filter(lambda x:tpye(x) == int,v1)#更简化
        print(list(result))
        
      3. reduce()

        import functools
        v1 = [11,22,33]
        def func (x,y):
            return x*y
        result = functools.reduce(func,v1)
        print(result)
        ----------------------------------
        import functools
        v1 = [11,22,33]
        result = functools.reduce(lambda x,y:x*y,v1)
        print(result)
        
  7. 模块

    1. md5

      import hashlib
      obj = hashlib.md5()
      obj.update('123'.encode('utf-8'))
      result = obj.hexdigest()
      print(result)
      

    2.加盐

    import hashlib
    obj = hashlib.md5('qwesdsafewafewafaef123d'.encode('utf-8'))
    obj.update('123'.encode('utf-8'))
    result = obj.hexdigest()
    print(result)
    
  8. 装饰器

    在不改变原函数的情况下,在函数之前或者之后做操作

    def func(arg):
        def inner():
            print('before')
            v = arg()
            print('after')
            return v
        return inner
    
    def index():
        print('123')
        return '666'
    
    index = func(index)
    index()
    
    def func(arg):
        def inner():
            print('before')
            v = arg()
            print('after')
            return v
        return inner
    
    @func #第一步:执行func函数并将下面的函数当作参数传递。相当于:func(index)
    	  #第二步:将func的返回值重新赋值给下面的函数名。index = func(index)
    def index():
        print('123')
        return '666'
    
    index()
    

Q.E.D.