python基础入门（二）

待我称王封你为后i 2022-05-29 04:56 343阅读 0赞

## 1.列表 ##

list类中提供的方法
    1. 原来值最后追加
    对象.方法(..)   # li对象调用append方法
        li.append(5)
        li.append("alex")
        li.append([1234,2323])
        print(li)
    2 清空列表
        li.clear()
        print(li)
    
    3 拷贝，浅拷贝
        v = li.copy()
        print(v)
    4. 计算元素出现的次数
        v = li.count(22)
        print(v)
    5. 扩展原列表，参数：可迭代对象，注意：append，extend区分开来。
        li = [11, 22, 33, 22, 44]
        li.append([9898,"不得了"])  作为整体加到列表
        输出：[11, 22, 33, 22, 44, [9898, '不得了']]
    
        li.extend([9898,"不得了"])   每一个元素单独加到列表
        for i in [9898,"不得了"]:
            li.append(i)
        输出：[11, 22, 33, 22, 44, 9898, '不得了']
    
        li.extend("不得了")
        print(li)
    
    6. 根据值获取当前值索引位置（左边优先）
        li = [11, 22, 33, 22, 44]
        v= li.index(22)
        print(v)
    
    7. 在指定索引位置插入元素
        li = [11, 22, 33, 22, 44]
        li.insert(0,99)
        print(li)
    
    8、 删除某个值(1.指定索引；2. 默认最后一个)，并获取删除的值
        li = [11, 22, 33, 22, 44]
        v1 = li.pop(3)   删除22
        v2 = li.pop()    删除44
        print(li)
        print(v)
    
    9. 删除列表中的指定值，左边优先
        li = [11, 22, 33, 22, 44]
        li.remove(22)
        print(li)
    
    删除元素的方法: pop remove del   clear（清空）
    
    10 将当前列表进行翻转
        li = [11, 22, 33, 22, 44]
        li.reverse()
        print(li)
    
    11 列表的排序
        li = [11,44, 22, 33, 22]
        li.sort()
        li.sort(reverse=True)
        print(li)
    列表格式，中括[]括起来
    列表中可以嵌套任何类型用，分割每个元素
    列表中的元素可以是 数字，字符串,列表，布尔值..所有的都能放进去
    索引取值
        print(li[3])
    切片，切片结果也是列表
        print(li[3:-1])
    列表元素，可以被修改
        li = [1, 12, 9, "age", ["abc", ["19", 10], "def"], "gh", True]
    修改
        li[1] = 120
        print(li)
        li[1] = [11,22,33,44]
        print(li)
    
    12 切片
    修改
        li[1:3] = [120,90]
        print(li)
    删除
        del li[2:6]
        print(li)
    
    13 in 操作
    li = [1, 12, 9, "age", ["a", ["19", 10], "b"], "c", True]
    v1 = "a" in li
    print(v1)
    v2 = "age" in li
    print(v2)
    
    14 转换类型
    #字符串转换列表 
    li =  list("asdfasdfasdf"), 内部使用for循环
    s = "pouaskdfauspdfiajsdkfj"
    new_li = list(s)
    print(new_li)
    
    #列表转换成字符串，
    需要自己写for循环一个一个处理： 既有数字又有字符串
    li = [11,22,33,"123","abc"]
    r = str(li) 
    print(r)
    # 输出：'[11,22,33,"123","abc"]'
    s = ""
    for i in li:
        s = s + str(i)
    print(s)   112233123abc
    
    #直接使用字符串join方法：要求列表中的元素只有字符串
    li = ["123","abc"]
    v = "".join(li)
    print(v)
    
    #列表创建后可修改，且列表有序
    #字符串创建后，不可修改
    v = "alel"
    v = v.replace('l','abc')
    print(v)    #aadceabc 全部替换
    
    li = [11,22,33,44]
    li[0]
    li[0] = 999
    
    s = "alex"
    li[0]
    s[0] = "E"   #报错

## 元组 ##

1. 书写格式
     tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
    一般写元组的时候，推荐在最后加入 ,
    元素不可被修改，不能被增加或者删除
    
    2. 索引
     v = tu[0]
     print(v)
    
    3. 切片
     v = tu[0:2]
     print(v)
    
    4. 可以被for循环，可迭代对象
     for item in tu:
     print(item)
    
    5. 转换
     s = "asdfasdf0"
     li = ["asdf","asdfasdf"]
     tu = ("asdf","asdf")
     v = tuple(s)
     print(v)
     v = tuple(li)
     print(v)
    
     v = list(tu)
     print(v)
    
     v = "_".join(tu)
     print(v)
    
     li = ["asdf","asdfasdf"]
     li.extend((11,22,33,))
     print(li)
    
    #6.元组的一级元素不可修改/删除/增加
    tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
    元组，有序。
    v = tu[3][0][0]
    print(v)
    v=tu[3]
    print(v)
    tu[3][0] = 567
    print(tu)
    
    7.基本函数调用
     tu = (11,22,33,44)
     tu.count(22),获取指定元素在元组中出现的次数
     tu.index(22) ，获取22的索引位置

## 字典 ##

#1、基本机构
        info = {
            "k1": "v1", # 键值对
            "k2": "v2"
        }
        # 2 字典的value可以是任何值
        info = {
            "k1": 18,
            "k2": True,
            "k3": [
                11,
                [],
                (),
                22,
                33,
                {
                    'kk1': 'vv1',
                    'kk2': 'vv2',
                    'kk3': (11,22),
                }
            ],
            "k4": (11,22,33,44)
        }
        print(info)
    
    #3 布尔值(1,0)、列表、字典不能作为字典的key
        info ={
            1: 'asdf',
            "k1": 'asdf',
            True: "123",
            # [11,22]: 123 报错
            (11,22): 123,
            # {'k1':'v1'}: 123 报错
    
        }
        print(info)
    
    #4 字典无序
    
        info = {
            "k1": 18,
            "k2": True,
            "k3": [
                11,
                [],
                (),
                22,
                33,
                {
                    'kk1': 'vv1',
                    'kk2': 'vv2',
                    'kk3': (11,22),
                }
            ],
            "k4": (11,22,33,44)
        }
        print(info)
        print(info)  #两次打印出来不相同
    
    5、索引方式找到指定元素
        info = {
            "k1": 18,
            2: True,
            "k3": [
                11,
                [],
                (),
                22,
                33,
                {
                    'kk1': 'vv1',
                    'kk2': 'vv2',
                    'kk3': (11,22),
                }
            ],
            "k4": (11,22,33,44)
        }
        v = info['k1']
        print(v)
        v = info[2]
        print(v)
        v = info['k3'][5]['kk3'][0]
        print(v)
    
    #6 字典支持 del 删除
        info = {
            "k1": 18,
            2: True,
            "k3": [
                11,
                [],
                (),
                22,
                33,
                {
                    'kk1': 'vv1',
                    'kk2': 'vv2',
                    'kk3': (11,22),
                }
            ],
            "k4": (11,22,33,44)
        }
        del info['k1']
    
        del info['k3'][5]['kk1']
        print(info)
    
    7 for循环
        dict
        info = {
            "k1": 18,
            2: True,
            "k3": [
                11,
                [],
                (),
                22,
                33,
                {
                    'kk1': 'vv1',
                    'kk2': 'vv2',
                    'kk3': (11,22),
                }
            ],
            "k4": (11,22,33,44)
        }
        for item in info:
            print(item)
    
        for item in info.keys():  找键
            print(item)
    
        for item in info.values():    找值
            print(item)
    
        for item in info.keys():
            print(item,info[item])
    
        for k,v in info.items():    一起拿键和值
            print(k,v)
    
    
    8 设置值，
    已存在，不设置，获取当前key对应的值
    不存在，设置，获取当前key对应的值
        dic = {
            "k1": 'v1',
            "k2": 'v2'
        }
        v = dic.setdefault('k1111','123')
        print(dic,v)  
    
    9 更新的两种传参方式
        dic = {
            "k1": 'v1',
            "k2": 'v2'
        }
        dic.update({
       'k1': '111111','k3': 123})
        print(dic)
        dic.update(k1=123,k3=345,k5="asdf")
        print(dic)

## str 字符串 ##

# 1 首字母大写
        test = "aLex"
        v = test.capitalize()
        print(v)
    
    # 2 所有变小写，casefold更牛逼，很多未知的对相应变小写
        v1 = test.casefold()
        print(v1)
        v2 = test.lower()
        print(v2)
    
    # 3 设置宽度，并将内容居中，左，右
    # 20 代指总长度
    # * 空白未知填充，一个字符，可有可无
        v = test.center(20,"中")
        print(v)
        test = "alex"
        v = test.ljust(20,"*") print(v) test = "alex" v = test.rjust(20,"*")
        print(v)
    
        test = "alex"
        v = test.zfill(20)   用0填充
        print(v)
    
    # 4 去字符串中寻找，寻找子序列的出现次数
        test = "aLexalexr"
        v = test.count('ex')
        print(v)
        test = "aLexalexr"
        v = test.count('ex',5,6)  #5,6 指定索引范围
        print(v)
    
    
    # 5 以什么什么结尾，以什么什么开始
        test = "alex"
        v = test.endswith('ex')
        v = test.startswith('ex')
        print(v)
    
    # 6 expandtabs,断句tabs为20，
        test = "username\temail\tpassword\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123"
        v = test.expandtabs(20)
        print(v)
    #输出 
    username            email               password
    laiying             ying@q.com          123
    laiying             ying@q.com          123
    laiying             ying@q.com          123
    
    # 7 从开始往后找，找到第一个之后，获取其位置
        test = "alexalex"
        未找到 -1
        v = test.find('ex')
        print(v)
    
    # 8 index找不到，报错 忽略
        test = "alexalex"
        v = test.index('8')
        print(v)
    
    
    # 9 格式化，将一个字符串中的占位符替换为指定的值
        test = 'i am {name}, age {a}'
        print(test)
        v = test.format(name='alex',a=19)
        print(v)
    
        test = 'i am {0}, age {1}'
        print(test)
        v = test.format('ndk',19)
        print(v)
    
    # 10 格式化，传入的值 {"name": 'alex', "a": 19}
        test = 'i am {name}, age {a}'
        v1 = test.format(name='df',a=10)
        v2 = test.format_map({
       "name": 'alex', "a": 19})
    
    
    # 11 字符串中是否只包含 字母和数字
        test = "123"
        v = test.isalnum()
        print(v)
    
    
    # 12 是否是字母，汉字
        test = "as2df"
        v = test.isalpha()
        print(v)
    
    # 13 当前输入是否是数字
        test = "二" # 1，②
        v1 = test.isdecimal()
        v2 = test.isdigit()
        v3 = test.isnumeric()
        print(v1,v2,v3)
    
    # 14 是否存在不可显示的字符
    # \t 制表符
    # \n 换行
        test = "oiuas\tdfkj"
        v = test.isprintable()
        print(v)
    
    # 15 判断是否全部是空格
        test = ""
        v = test.isspace()
        print(v)
    
    # 16 判断是否是标题
        test = "Return True if all cased characters in S are uppercase and there is"
        v1 = test.istitle()
        print(v1)
    
    # 17 ***** 将字符串中的每一个元素按照指定分隔符进行拼接
        test = "你是风儿我是沙"
        print(test)
        t = ' '
        v = "_".join(test)
        print(v)
    
    # 18 判断是否全部是大小写 和 转换为大小写
    test = "Alex"
    v1 = test.islower()
    v2 = test.lower()
    print(v1, v2)
    
    v1 = test.isupper()
    v2 = test.upper()
    print(v1,v2)
    # 19移除指定字符串，有限最多匹配
    test = "xa"
    v = test.lstrip('xa')
    v = test.rstrip('9lexxexa')
    v = test.strip('xa')
    print(v)
    
    # 去除左右空白 去除\t \n
    v = test.lstrip()
    v = test.rstrip()
    v = test.strip()
    print(v)
    
    # 20 对应关系替换
    test =  "aeiou"
    test1 = "12345"
    v = "asidufkasd;fiuadkf;adfkjalsdjf"
    m = str.maketrans("aeiou", "12345")
    new_v = v.translate(m)
    print(new_v)  #输出1s3d5fk1sd;f351dkf;1dfkj1lsdjf 将对应字符替换
    
    # 21 分割为三部分
    test = "testasdsddfg"
    v = test.partition('s')
    print(v)   #('te', 's', 'tasdsddfg')
    v = test.rpartition('s')
    print(v)   #('testasd', 's', 'ddfg')
    
    # 22 分割为指定个数
    v = test.split('s',2)
    print(v)
    test.rsplit()
    
    # 23 分割，只能根据，true，false：是否保留换行（True保留，False不保留）
    test = "asdfadfasdf\nasdfasdf\nadfasdf"
    v = test.splitlines(True)
    print(v)  #['asdfadfasdf\n', 'asdfasdf\n', 'adfasdf']
    
    
    # 24 字母，数字，下划线 ： 标识符 def class
    a = "def"
    v = a.isidentifier()
    print(v)
    
    
    # 25 将指定字符串替换为指定字符串
    test = "alexalexalex"
    v = test.replace("ex",'bbb')
    print(v)
    v = test.replace("ex",'bbb',2)  #替换次数
    print(v)