python的语法系列（2）

1.数据类型

    （1）.数字类型

                整型（int）

                长整型（python3去掉了）

                浮点型（float）

      （2）.布尔类型

                真/假

       （3）.字符串

           “张三丰”‘

       （4）.复数（可以忽略了）

 

2.列表的操作

  定义列表

    course = ['shuxue',"yuwen",'yingyu']

    列表的访问

    course[0] = "shuxue" course[2]="yingyu"   course[-1] = "yingyu" course[-2]="yuwen"

    如果倒着取，则-1为下标的起始位置。

    列表的切片（取多个元素）

    courses = ["java","python","go","kotlin","guava","javascript"]

    course[1:4]  取下标1至4之间的内容，顾头不顾腚，即包括1不包括4.

    course[1:-1] 取下标1至-1之间的内容 ["python","go","kotlin","guava"]

    course[0:3]  ["java","python","go"]

    course[:3] 如果是从头开始取，0可以忽略，跟上句效果一样。

    course[3:] 如果想取到最后一个，不能写-1 ，只能这么写。

    course[3:-1]  ["kotlin","guava"]

    course[0::2] 后边的2代表每隔一个元素就取一个  ["java","go","guava"]

    course[::2] 和上句效果一样

    列表的追加

    course.append("lua")

    ["java","python","go","kotlin","guava","javascript","lua"]

    列表的插入

    course.insert(2,"shell")

    ["java","python","shell","go","kotlin","guava","javascript","lua"]

    列表的修改

    course[2] = "ruby"

    ["java","python","ruby","go","kotlin","guava","javascript","lua"]

    列表的删除

    del course[2]

    ["java","python","go","kotlin","guava","javascript","lua"]

    course.remove("lua")  删除指定元素

    ["java","python","go","kotlin","guava","javascript"]

    course.pop() 删除列表最后一个值

    ["java","python","go","kotlin","guava"]

    列表的扩展

    c = ["shell","lua"]

    course.extend(c)

    ["java","python","go","kotlin","guava","shell","lua"]

    列表的拷贝

    course_copy = course.copy()

    >>>course_copy 

    ["java","python","go","kotlin","guava","shell","lua"]

    列表的统计

    course.count("java")  列表中只有一个java，因此返回结果为1

    列表的排序&翻转

    course.sort()  如果是不同数据类型的列表，python3会发生错误，因为python3不支持不同数据类型的列表进行排序。对列表升序

    course.reverse() 对列表进行翻转

    获取下标

    course.index("go")  ---> 2  如果列表中有重复的元素 ，只返回找到的第一个下标

   3.元组的操作

    元组其实跟列表差不多，也是存一组数，只不过它一旦创建，便不能再修改，所以又叫只读列表。它只有两个方法，一个是count，一个是index. 

    course = ("java","go","python")

    course.count("java") course.index("go")

   4.字符串操作(特性：不可修改)

    course.capitalize() 首字母大写

     course.casefold() 大写变小写

     course.center(50,"-") 

     course.count("java") 统计“java”出现的次数

     course.encode() 将字符串编码成byte[]

     course.endswith("ZH") 判断字符串是否以“ZH”结尾

     course.find("A") 查找A，找到返回其索引，找不到返回-1

   “zh\tPeng”.expandtabs(10) 将\t转换成多长的空格   

      strip

      split()

      replace(o,n)

     format：

        >>>msg = "my name is {} , and age is {}"

        >>>msg.format("张三丰",18)

        "my name is  张三丰 ， and age is 18"

         >>>msg = "my name is {1} , and age is {0}"

         >>>msg.format("张三丰"，18)

         "my name is 18 , and age is 张三丰"

         >>>msg = "my name is {name} , and age is {age}"

         >>>msg.format(age=18,name="张三丰")

         "my name is 张三丰，and age is 18"

          msg.index("z") 返回z所在字符串的索引

          msg.isalnum()  False 检查字符串是否由数字和字母组成

          msg.isdigit()     检查字符串是否整数

          msg.isnumeric  检测字符串是否只由数字组成。这种方法是只针对unicode对象。 str = u "msg"

          msg.isprintable  判断是否为可打印字符串

          msg.isspace 判断是否为空格

          msg.istitle 判断是否首字母大写，其他字母小写

          islower()/isupper()  判断是否为小写/大写

         >>>"|".join(["java","python","go"])

         >>>"java|python|go"

          msg.swapcase 大小写互换

       

     5.字典操作  （字典是另一种可变容器模型，且可存储任意类型对象）

       字典特性：字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。

          两个重要的点需要记住：

                1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住

                2）键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行

                info = {

                    "name":" 张三丰"，

                   “age” :18

                 }

        

       字典是无序的，key必须是唯一的

 

       字典增加

        >>>info["sex"]="man"

        >>>info

        {"name":"张三丰"，"age":"18","sex":"man"}

        >>>info["name"]="zhang3feng"

        >>>info

        >>>{"name":"zhangsanfeng"，"age":"18","sex":"man"}

       字典修改

        >>>info["name"]="小泽玛利亚"

        >>>info

        >>>{"name":"小泽玛利亚"，"age":"18","sex":"man"}

       字典删除

        >>>info.pop("小泽玛利亚")  标准删除姿势

        >>>del info["name"]  另一种删除

        >>>info.popitem() 随机删除

        >>>info.clear() 清空字典所有条目

        >>>del info 删除整个字典

        >>>info.copy() 返回一个字典的浅复制

       字典查找

        >>>"name" in  info 标准用法

        True

        >>>info.get("name") 获取

        "小泽玛利亚"

        >>>info["name"] 同上  与get的区别，如果key不存在，就报错，get不会，返回None

        多级字典嵌套及操作

         "欧美":{

 

            "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
            "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
            "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
            "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
        },
         "日韩":{
            "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
        },
         "大陆":{
            "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]

 

        }

 

         av_catalog["大陆"]["1024"][1] += ",可以用爬虫爬下来"

 

         print(av_catalog["大陆"]["1024"]

 

         ['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']

        循环字典

        #方法1
            for key in info:
                print(key,info[key])
        #方法2
            for k,v in info.items(): #会先把dict转成list,数据里大时莫用
                print(k,v)

    

      6.集合操作

        s = set([3,5,9,10])      #创建一个数值集合    
        t = set("Hello")         #创建一个唯一字符的集合  
        a = t | s          # t 和 s的并集  
        b = t & s          # t 和 s的交集    
        c = t – s          # 求差集（项在t中，但不在s中）  
        d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）  
   
        基本操作：  
            t.add('x')            # 添加一项  
            s.update([10,37,42])  # 在s中添加多项  
            使用remove()可以删除一项：  
            t.remove('H')  
            len(s)   set 的长度    
            x in s    测试 x 是否是 s 的成员  
            x not in s   测试 x 是否不是 s 的成员  
            s.issubset(t)  
            s <= t   测试是否 s 中的每一个元素都在 t 中
            s.issuperset(t)  
            s >= t  测试是否 t 中的每一个元素都在 s 中  
            s.union(t)  
            s | t    返回一个新的 set 包含 s 和 t 中的每一个元素  
            s.intersection(t)  
            s & t   返回一个新的 set 包含 s 和 t 中的公共元素   
            s.difference(t)  
            s - t   返回一个新的 set 包含 s 中有但是 t 中没有的元素
            s.symmetric_difference(t)  
            s ^ t   返回一个新的 set 包含 s 和 t 中不重复的元素
            s.copy()   返回 set “s”的一个浅复制