week2 notebook2

Beginning day2:

1.基础数据类型宏观：

1.1.整型：int:1,2,3

1.2.字符串：str:‘anthony’
    1.2.1:
            索引：索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。
                a = 'ABCDEFGHIJK'
                print(a[0])
                print(a[3])
                print(a[5])
                print(a[7])

            切片：切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。
                a = 'ABCDEFGHIJK'
                print(a[0:3])
                print(a[2:5])
                print(a[0:]) #默认到最后
                print(a[0:-1]) #-1就是最后一个
                print(a[0:5:2]) #加步长
                print(a[5:0:-2]) #反向加步长

    1.2.2:常用方法：
            #captalize,swapcase,title
            print(name.capitalize()) #首字母大写
            print(name.swapcase()) #大小写翻转
            msg='egon say hi'
            print(msg.title()) #每个单词的首字母大写

            # 内同居中，总长度，空白处填充
            ret2 = a1.center(20,"*")
            print(ret2)

            #数字符串中的元素出现的个数。
            # ret3 = a1.count("a",0,4) # 可切片
            # print(ret3)

            a2 = "hqw\t"
            #\t前面的补全
            # 默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，如果tab键前面的字符长度超过8个不足16个则补全16个，以此类推每次补全8个。
            ret4 = a2.expandtabs()
            print(ret4)

            a4 = "dkfjdkfasf54"
            #startswith 判断是否以...开头
            #endswith 判断是否以...结尾
            # ret4 = a4.endswith('jdk',3,6)  # 顾头不顾腚
            # print(ret4)  # 返回的是布尔值
            # ret5 = a4.startswith("kfj",1,4)
            # print(ret5)

            #寻找字符串中的元素是否存在
            # ret6 = a4.find("fjdk",1,6)
            # print(ret6)  # 返回的找到的元素的索引，如果找不到返回-1

            # ret61 = a4.index("fjdk",4,6)
            # print(ret61) # 返回的找到的元素的索引，找不到报错。

            #split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。
            # ret9 = 'title,Tilte,atre,'.split('t')
            # print(ret9)
            # ret91 = 'title,Tilte,atre,'.rsplit('t',1)
            # print(ret91)

            #format的三种玩法 格式化输出
            res='{} {} {}'.format('egon',18,'male')
            res='{1} {0} {1}'.format('egon',18,'male')
            res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)

            #strip
            name='*egon**'
            print(name.strip('*'))
            print(name.lstrip('*'))
            print(name.rstrip('*'))

            #replace
            name='alex say :i have one tesla,my name is alex'
            print(name.replace('alex','SB',1))

            #####is系列
            name='jinxin123'
            print(name.isalnum()) #字符串由字母或数字组成
            print(name.isalpha()) #字符串只由字母组成
            print(name.isdigit()) #字符串只由数字组成

1.3.布尔：bool:true,false
        真   1   True。
        假   0   False。
　　　　　

　　　　　# 布尔值比较

　　　　　　　　同为数字,and去后,or去前
　　　　　　　　False 和 True与数字比较,大于都为false，小于都为true

1.4.列表:
    list:['123','anthony']
    a.增加：append

    b.删除：
    按索引删除：pop #有返回值
    按元素删除：remove
    直接删除：del：a.删除列表  b.删除索引 c.按照切片删除

    c.修改：
    按照索引修改：l[0] = 'anthony'
    按照切片修改：1:[:3] =
    按照步长修改：[1:2:2] =

    d.查询：
    # 按照索引、切片(步长)：
    a. for(有限循环)

    e.其他方法：
    print(len(l)) #总个数
    print(l.count('WuSir'))

    sort 排序：
    ll = [1,2,3,6,5,7,9,2,5,4]
    正序排序：sort
    倒序排序：ll.sort(reverse=True)
    翻转排序：ll.reverse()

    f.list example：

        li = [1,9,6,7, 2, 3, 4]

        # 增加：
        # li.insert(0,5)
        # li.append('r')
        # li.extend('fjsldjf')

        # 删除：

        # li.pop(1) # 按照位置删除，有返回值
        # del li[0]   # 按位置直接删除，没有返回值
        # li.remove('a')  # 按照元素删除
        # li.clear() # 清空列表

        # 修改
        # li[0] = 'aaa'

        # # 查询：
        # li[0]   #切片查
        # print(li[0])

        # 其他方法：
        # print(len(li))  #总个数
        # print(li.count(1))  #每个元素出现的次数
        # li.sort()   # 正向排序
        # li.sort(reverse=True) #反向排序
        # li.reverse()    #翻转排序
        print(li)
1.5.元祖:
        l1 = [1, 2, 'alex', ['WuSir', 'taibai', 99], 6]
        l1[2] = l1[2].capitalize()
        l1[3][0] = l1[3][0].upper()
        l1[3][2] = str(l1[3][2]+1)
        print(l1)

1.6.列表嵌套：
    遍历range:
            l1 = [1, 2, 3, 4, 5, 'alex']
            for i in range(len(l1)):
                print(i)
     常见入坑：
            # ll = [11,22,33,44,55]
            #
            # for i in range(len(ll)-1,-1,-1):
            #     if i % 2 == 1:
            #         del ll[i]
            # print(ll)

            # del ll[1::2]

1.7.字典:
    含义：
        a.字典：key-values存储，可以存储大量的的关系型数据，查询速度非常快。
        b.字典的键 必须是唯一的，不可重复，value 可以为任意数据类型或者对象。
        c.字典的键只能是不可变的数据类型：
        d.数据类型的分类：
            不可变（可哈希的）得数据类型：int str tuple bool
            可变的（不可哈希的）数据类型：dict，list，set
        e. 3.5版本包括3.5之前都是无序的。
    增加：
        dic['name'] = 'anthony'
    删除:
        pop:
            pop:根据键(key)删除
            popitem:随机删除，有返回值。
        del:删除整个字典或按照键值对删除
        clear：清空字典
    修改：
        dic['name'] = 'anthony'   #无责增加，有责改之
        update：
    查询：
            # value1 = dic["name"]  # 没有会报错
            # print(value1)
            #
            # value2 = dic.get("djffdsafg","默认返回值")  # 没有可以返回设定的返回值
            # print(value2)
     其他方法：
            dic.keys()
            dic.values()
            dic.items()

     常见入坑：
            dic = {'k1': 'v1', 'k2': 'v2', 'k3':'v3', 'name':'alex'}
            lists = []
            for key in dic:
                if 'k'  in key:
                    lists.append(key)
            for i in lists:
                del dic[i]
            print(dic)
     字典嵌套：