python基础篇

python基础篇

1. 整数int

   加 print(3+8)
   减 print(3-8)
   乘 print(3*8)
   除 print(3/8)
   取整除 - 返回商的整数部分（向下取整）print(17//3)
   取模 - 返回除法的余数  print(17%3)
   幂，0.5次方就是开方  print(8**0.5)
   向下取整数 print(int(0.5))
   求绝对值 print(abs(-1))
   将一个整数转换为一个十六进制字符串 print(hex(13))
   将一个整数转换为一个八进制字符串 print(oct(13))
   将一个整数转换为一个二进制字符串 print(bin(13))
######### 位运算 #########
   print(bin(13))
   001101
   print(bin(60))
   111100
#与，如果两个相应位都为1，则该位的结果为1，否则为0，结果为001100
   print(13&60)
# 或，只要两个相应位有一个为1，结果位就为1，结果111101
   print(13|60)
# 异或，当同位相同时结果为0，不同结果为1，结果为110010
   print(13^60)
# 作用：奇偶判断，a=4，他的二进制为1010，而1^0^1^0=0，因为结果为0，所以a是偶数

2. str 字符串

     # 字符串遍历
     for ch in my_str4:
         print(ch, end=' ')
     #方法说明
     #string.isalpha()   如果 string 至少有一个字符并且所有字符都是字母则返回 True
     #string.isdecimal() 如果 string 只包含数字则返回 True
     #string.islower()   如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True
     #string.isupper()   如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True
     #string.startswith(str) 检查字符串是否是以 str 开头，是则返回 True
     #string.endswith(str)   检查字符串是否是以 str 结束，是则返回 True    
     content = input('请输入内容:')
     if content.isalpha():
        print('全部都是字母!')
     if content.isdecimal():
        print('其中包含数字!')
     if content.isdigit():
        print('输入的内容是数字!')
     if content.islower():
        print('全是小写')
     if content.startswith('ab'):
        print('字符串以ab开头')
      #方法说明
      #string.find(str, start=0, end=len(string)) 检测 str 是否包含在 string 中，如果 start 和 end 指定范围，则            检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 -1
      #string.rfind(str, start=0, end=len(string))    类似于 find()，不过是从右边开始查找
      #string.index(str, start=0, end=len(string))    跟 find() 方法类似，不过如果 str 不在 string 会报错
      #string.rindex(str, start=0, end=len(string))   类似于 index()，不过是从右边开始
      #string.replace(old_str, new_str, num=string.count(old))    返回一个新字符串，把 string 中的 old_str 替换      成 new_str，如果 num 指定，则替换不超过 num 次
      my_str = 'abcdefghijcdklmn'
      my_str.find('cd')
      my_str.rfind('cd')
      my_str.index('cd')
      my_str.rindex('cd')
      # 替换之后返回一个新的字符串
      my_str.replace('cd', '888')
      # 返回元组，把字符串 string 分成一个3元素的元组 (str前面, str, str后面)
      my_str = 'abcdghiefghijcdklmn'
      print(my_str.partition('ghi'))

      # 字符串拆分，返回列表，以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 '\r', '\t', '\n' 和空格
      my_str = 'aaa bbb ccc ddd'
      my_str_list = my_str.split(' ')
      print(my_str_list)

      # 只拆第一个
      txt = "Google#Runoob#Taobao#Facebook"
      x = txt.split("#，1")
      print(x)
      # 列表拆分，返回字符串，以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串
      my_list = ['obama', 'john', 'smith', 'polly']
      print('#'.join(my_list))
      # 返回列表，按照行('\r', '\n', '\r\n')分隔
      my_str = 'aaa\nbb\nccc'
      print(my_str.splitlines())
      #方法说明
      string.lower() 返回新字符串，转换 string 中所有大写字符为小写
      string.upper() 返回新字符串，转换 string 中的小写字母为大写
      # 文本对齐
      string.ljust(width)    返回新字符串，基于原字符串左对齐，并使用空格填充至长度 width
      string.rjust(width)    返回新字符串，基于原字符串右对齐，并使用空格填充至长度 width
      string.center(width)   返回新字符串，基于原字符串居中，并使用空格填充至长度 width
      # 去除空白字符
      string.lstrip()    返回新字符串，截掉 string 左边（开始）的空白字符
      string.rstrip()    返回新字符串，截掉 string 右边（末尾）的空白字符
      my_str1 = 'abc'
      my_str2 = 'ABC'
      print(my_str1.upper())
      print(my_str2.lower())
      my_str3 = '   abc   '
      print(my_str3.lstrip())
      print(my_str3.rstrip())
      print(my_str3.strip())
      my_str4 = 'abcd'
      new_string = my_str4.ljust(20)
      new_string = my_str4.rjust(20)
      new_string = my_str4.center(20)
      print(new_string)
      #字符串切片
      my_str = 'abcdefg'
      # 如何获得b字符?
      print(my_str[1])
      # Python支持在中括号里存放两个整数
      print(my_str[1: 5])
      # 切片语法 左闭右开的区间
      # 如何获得defg
      print(my_str[3:7])
      # 字符串下表支持负数
      print(my_str[-1])
      # 第二个参数省略的话，默认到最后
      # 第一个参数省略的话，默认从0开始
      # 第三个参数省略的话，默认步长是1
      print('AAA:', my_str[::])
      # 步长也可以是负数 （回文，倒序排列）
      print(my_str[::-1])

3. list 列表

    #列表增加
    my_list.append(777)
    my_list.insert(1, '888') 
    # 列表合并
    my_list.extend(my_list2)
    #列表删除
    # 删除指定索引的数据
    del my_list[1]
    # 只会删除第一次出现的值
    my_list.remove(40)
    # 删除末尾数据
    my_list.pop()
    # 清空列表
    my_list.clear()
    # 根据值查询对应的索引
    my_list.index(3)
    # 统计数据出现次数
    my_list.count(2)
    # 最大值，最小值
    max(my_list)
    min(my_list)
    # 排序， 默认从小到大
    my_list.sort()
    # 降序
    my_list.sort(reverse=True)
    # 排序,处理的一般是可迭代对象，不会直接修改原列表，通常用它替代sort()
    sorted(my_list)
    # 反转列表
    my_list.reverse()
    # 遍历列表返回下标和元素  
    seq = ['one', 'two', 'three']
    for i, element in enumerate(seq):
        print i, element

4. set 集合

   1. 字典是键值对，键值不能重复
   2. 集合值, 值不能重复
   3. 集合也是无序的， 也就是相当于没有下标 没有索引
   4. 集合一般用来去重
   my_set = {10, 20, 30, 10, 20, 20, 20}
   print(my_set, type(my_set))

5. tuple 元组操作

   # 元组和列表最大的区别？ 元组中的元素不能修改，列表中的元素可以任意修改.
   my_tuple = (10, 20, 30, 40)
   print(my_tuple[0], my_tuple[1], my_tuple[2])
   # 如果元组中只有一个元素的时候，添加一个逗号
   my_tuple = (10,)
   print(type(my_tuple))
   #解构
   my_tuple = (10, 20)
   a, b = my_tuple
   print(a, b)      

6. dict 字典

   my_dict = {'name': 'Obama', 'age': 48, 'gender': '女',}
   # 访问字典中的元素
   my_dict['name']
   # 只能通过下标去访问元素, 不支持索引
   my_dict[0]
   #插入
   my_dict = {'name': 'Obama', 'age': 48, 'gender': '女'}
   my_dict['name'] = 'Trump'
   # 如果key存在会覆盖
   # 删除操作
   my_dict.pop('gender')
   # 清空字典
   my_dict.clear()
   # 键值对不存在，则添加键值对；存在则不做处理
   my_dict.setdefault('age', 18)
   # 取出字典2的键值对，键值对不存在，添加键值对；存在则修改值
   my_dict2 = {'name': 'Obama', 'age': 10, 'gender': '女', 'attack': 100}
   my_dict.update(my_dict2)
   #查询  字典[键]  根据键取值，键值对不存在会报错
   #字典.get(键)  根据键取值，键值对不存在不会报错
   #字典.keys()  可进行遍历，获取所有键
   #字典.values()    可进行遍历，获取所有值
   #字典.items() 可进行遍历，获取所有(键，值)
   #遍历 for key in 字典  取出元组中的每个元素的 key
   my_dict = {'name': 'Obama', 'age': 48, 'gender': '女'}
   # 使用中括号方式访问字典中的元素，如果key不存在则报错
   print(my_dict.get('name', 'abc'))  #前面的不存在才会查看后面元素
   print('打印所有的key:', my_dict.keys())
   print('打印所有的value:', my_dict.values())
   print('打印所有的key-value:', my_dict.items())
   # 遍历字典
   for key, value in my_dict.items():
        print(key, value)
        
   for item in my_dict.items():
        print(item[0], item[1])

7. def 函数

   def my_function():
       """这是我的第一个函数"""
       for i in range(1, 7):
          for j in range(1, i + 1):
              print('%d * %d = %d' % (i, j, i * j), end='\t')
    # 调用函数
    my_function()
    print('打印九九乘法表!')
    my_function()
    # 如果函数有参数的话，那么在调用函数的时候必须传递参数
    def my_func():
    print('aaa')
    return
    # 函数中只要执行了return 语句， 函数马上终止
    # 如果说return后面有值，则将值返回给调用者.
    # 如果return后面没没有值, 那么返回None
    print('bbb')
    ret = my_func()
    print(ret)
    # 局部变量，在函数内部定义变量
    # 局部变量只能在函数内部有效
    #  全局变量可以使用，但是不能直接修改，如果需要修改的话，需要使用global关键字声明
    def my_func03():
    # 声明全局变量
    global global_param
    global_param = 500
    print(global_param)
    my_func03()
    print(global_param)
    def my_plus(a=0, b=0, c=0):
    return a + b + c
    # 如果函数有参数的话，必须传递参数
    ret = my_plus(10, 20, 30)
    print(ret)
    # 如果我不传递参数的话
    ret = my_plus(10)
    print(ret)
    ret = my_plus(10, 100)
    print(ret)

8. class 类

   1. 封装的本质是将事物相关的属性和方法封装在一个类里面，我们调用类创建实例的时候，不用关心类内部的代码细节，相当于一个黑箱子，我们只需要该实例(黑箱)能给出我们想要的结果就好了。
   2. 子类可以复用父类里面的属性或者方法，当然子类还可以提供自己的属性和方法
   3. 使用类的继承实现约束子类中必须要实现某个方法，否则就会报错
      class BasePlugin(object):
       """
         基类，用于做约束。约束子类中必须实现process方法。
       """
            def process(self):
            raise NotImplementedError("%s中必须实现process方法" %self.__class__.__name__)

       class DiskPlugin(BasePlugin):
             pass

       class MemoryPlugin(BasePlugin):
             pass

        obj = MemoryPlugin()
        obj.process()
   4. ● 实例方法：由对象调用；至少一个self参数；执行实例方法时，自动将调用该方法的对象赋值给self；
      ● 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类赋值给cls；
      ● 静态方法：由类调用；无默认参数
      class Foo(object):
      def __init__(self, name):
          self.name = name
      def ord_func(self):
          """ 定义实例方法，至少有一个self参数 """
          # print(self.name)
          print('实例方法')
      @classmethod
      def class_func(cls):
          """ 定义类方法，至少有一个cls参数 """
          print('类方法')
      @staticmethod
      def static_func():
          """ 定义静态方法 ，无默认参数"""
          print('静态方法')
      f = Foo("中国")
      # 调用实例方法
      f.ord_func()
      # 调用类方法
      Foo.class_func()
      # 调用静态方法
      Foo.static_func()
   5. 装饰器本质上是一个函数或类，它可以让其他函数在不需要修改任何代码的前提下增加额外功能，装饰器的返回值也是一个函数/类对象。可以理解为面向切面编程，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码到装饰器中并继续重用。
    #闭包
    # print_msg是外围函数
     def print_msg():
         msg = "I'm closure"
    
         # printer是嵌套函数
         def printer():
             print(msg)
          return printer

     closure = print_msg()
     closure() 
     #装饰器
     from time import ctime, sleep
     def timefun(func):
         def wrapped_func(a, b):
             print("%s called at %s" % (func.__name__, ctime()))
             print(a, b)
             func(a, b)
          return wrapped_func

     @timefun
     def foo(a, b):   <--这里带参数
         print(a+b)

     foo(3, 5)
     @classmethod（类方法）
     #当我们需要和类直接进行交互，而不需要和实例进行交互时。类方法与实例方法类似，但是传递的不是类的实例，而是类本身，第一个参数是cls。我们可以用类的实例调用类方法，也可以直接用类名来调用。
     class A:
          class_attr = "attr"
          def __init__(self):
          pass        
    
          @classmethod
          def class_foo(cls):
          print("log is enabled")

         # 类方法可以通过（类名.方法）来调用：
          A.class_foo()
     #@staticmethod
     #（静态方法）方法中既不使用类对象,也不使用实例对象节省性能，静态方法类似普通方法，参数里面不用self。这些方法和类相关，但是又不需要类和实例中的任何信息、属性等等。如果把这些方法写到类外面，这样就把和类相关的代码分散到类外，使得之后对于代码的理解和维护都是巨大的障碍。而静态方法就是用来解决这一类问题的。
        class A:
             class_attr = "attr"
             def __init__(self):
             pass     
    
             @staticmethod
             def static_foo():
                 if log_enabled:
                    print("log is enabled")

             A.static_foo()     
      #@property（将方法变成属性调用）
      #作用：我们可以使用@property装饰器来创建只读属性，@property装饰器会将方法转换为相同名称的只读属性，可以与所定义的属性配合使用，这样可以防止属性被修改。 
      class DataSet(object):
            def __init__(self):
                self._images = 1
                self._labels = 2 #定义属性的名称
        
            @property
            def images(self): #方法加入@property后，这个方法相当于一个属性，这个属性可以让用户进行使用，而且用户有没办法随意修改。
                return self._images 
    
            @property
            def labels(self):
                return self._labels
      l = DataSet()
      # 加了@property后，可以用调用属性的形式来调用方法,后面不需要加()。
      print(l.images)
      print(l.labels)  
      #魔法属性
      __init__ :      构造函数，在生成对象时调用
      __del__ :       析构函数，释放对象时使用
      __repr__ :      打印，转换
      __setitem__ :   按照索引赋值
      __getitem__:    按照索引获取值
      __len__:        获得长度
      __cmp__:        比较运算
      __call__:       调用
      __add__:        加运算
      __sub__:        减运算
      __mul__:        乘运算
      __div__:        除运算
      __mod__:        求余运算
      __pow__:        幂   
      1. __doc__  
         ● 表示类的描述信息，Python自建，无需自定义。
         class Foo:
               """ 描述类信息，这是用于看片的神奇 """
              def func(self):
                  pass
         print(Foo.__doc__)
         #输出：类的描述信息
      2. __module__ 和 __class__
        ● __module__ 表示当前操作的对象在那个模块
        ● __class__ 表示当前操作的对象属于哪个类 
        test.py
        class Person(object):
              def __init__(self):
                  self.name = 'laowang'  
        main.py
        from test import Person
        obj = Person()
        print(obj.__module__)  # 输出 test 即：输出模块
        print(obj.__class__)  # 输出 test.Person 即：输出类   
       3.__init__  和 __new__
        ● new是在实例创建之前被调用的，因为它的任务就是创建实例然后返回该实例对象
        ● init是初始化方法，通过类创建对象时，自动触发执行
        ● 只有在new返回一个cls的实例时后面的init才能被调用
        ● 当创建一个新实例时调用new，初始化一个实例时用init 
        class Cat:
            def __new__(cls, name):
                print("创建对象")
                return object.__new__(cls)

            def __init__(self, name):
                print("对象初始化")
                self.name = name    # 自动执行类中的 __init__ 方法

            def __str__(self):
                return "%s" % self.name
   
        lanmao = Cat("蓝猫")
        lanmao.age = 20
        print(lanmao)      

9. 数据相互转换

    列表==>字典
    # 2个列表转换为字典
    dict1 = {}
    def demo():
        a = ["name" , "age" , "sex"]
        b = ["xiaoming" , 18]
        for i in range(len(a)):
        try:
            dict1[a[i]] = b[i]
        except:
            pass
    print(dict1)
    demo()
    # 使用内置函数 zip 
    a = ["name", "age"]
    b = ["xiaoming", 18]
    c = dict(zip(a,b))
    print(c)
    #字典==>列表
    dict1 = {'name': 'xiaoming', 'age': 18}
    list1 = list(dict1.keys())
    list2 = list(dict1.values())
    print(list1,list2)
    #字符串===>json
    import json
    msg = "{'name': 'CP', 'id': '', 'pageno': 1}"
    dic = json.loads(msg)