python基础入门（二）

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)