Python零基础知识点整理

Python早已“火”出圈，零基础小白上车，滴滴~

干货分享

6. python 学习
6-1. 字段串 format：
  输出字符串的两种方法：
   l = 'Life is short,{}';
   y = 'you need Python';
   res = l.format(y);
   print(res);


   tem = '{l1}{y1}';
   l1 = 'Life is short,';
   y1 = 'you need Python';
   tem = tem.format(l1=l1,y1=y1);
   print(tem);

6-2) 字符串切片 []
   s = 'ABCDEFGHIJK'
   r = s[0:4] # 取字符串s中的第一个字符到第五个字符，不包括第五个字符
   print(r) # ==> ABCD

6-3) 常用语句用法：
    6-3-1) if语句
           # coding: utf-8
           age = 4
           if age >= 18:
               print('adult 成年')
           elif age >= 6:
               print('teenager 青少年')
           elif age >= 3:
               print('kid 小孩子')
           else:
               print('baby 婴儿')

    6-3-2) for循环
            s = 'ABCD'
            for ch in s:
                print(ch) # 注意缩进

    6-3-3) while循环
            # coding:utf-8
            num = 1
            sum = 1
            while num <= 9:
                sum = sum * num # 注意缩进
                num = num + 1 # 注意缩进
            str = "1~10的乘积是:{sum}";
            str = str.format(sum=sum);
            print(str)

    6-3-4) while break跳出循环
            # coding: utf-8
            num = 0;
            sum = 0;
            while True:
                if num > 1000:
                    break
                sum = sum+num
                num = num+2
            print(sum)
    6-3-5) continue 继续循环
               # coding: utf-8
               num = 0;
               sum = 0;
               while num<1001:
                   if num%2==1 :
                       break
                   sum = sum+num
                   num = num+2
               print(sum) #求1~1000内偶数的和

    6-3-6) for 嵌套循环
            s1 = 'ABC'
            s2 = '123'
            for x in s1:
                for y in s2:
                    print(x + y)

6-4) list 容器
    6-4-1) 按索引访问list
            L = ['hd','jyt','jxl'];
            print(L[0])

            切片：
               print(L[0:2]);

    6-4-2) 倒序索引：
           L = ['hd','jyt','jxl'];
           print(L[-3])

    6-4-3) 添加新元素
            append() 追加到列表的末尾  arr.append('xjd');
            insert() 参数：插入的位置，插入的元素    arr.insert(2,'xjd')

    6-4-4) 删除元素
            pop()方法默认删除列表的最后一个元素，并返回。
               说明： 无参数，则表示删除最后一个；
                      有参数，指定需要删除的元素的位置； arr.pop(2);
    6-4-5) 修改元素
            arr[0] = 'xjd'

    6-4-6) 二维list
        例子：有三个长方体，他们的长宽高分别是[1, 2, 3], [5, 3, 2], [7, 3, 2]，定义在数组L中，L = [[1, 2, 3], [5, 3, 2], [7, 3, 2]]，请分别求出三个长方体的表面积。
            L = [[1, 2, 3], [5, 3, 2], [7, 3, 2]];
            for cube in L:
                length = cube[0]
                width = cube[1]
                height = cube[2]
                result = length * width * 2 + width * height * 2 + length * height * 2
                print(result)
6-5) tuple 元组容器
    6-5-1) tuple() list() 可将元素、列表类型互转
           但tuple格式，其每一个元素都不可被改变，同时也不能再往tiple中添加数据，而list是可以的。
           格式： T = ('hd','jyt');
                  list(T) #转为list格式
    6-5-2) count()方法  统计tuple中某个元素出现的次数
               T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
               print(T.count(1)) # ==> 3
               print(T.count(5)) # ==> 1
               ps: 对于不存在的元素，count方法不会报错，而是返回0；
           index()方法    返回指定元素的下标，当一个元素多次出现时，则返回第一次出现的下标位置
                ps: 指定的元素不存在时，会报错；
    6-5-3) 单个元素
           要定义只有一个元素的tuple，需要在元素后面添加一个逗号, 否则 输出一个元素时没有括号
           T = (1)
           print(T) # ==> 1

6-6) Dict容器
     d = {
         'Alice': 45,
         'Bob': 60,
         'Candy': 75,
         'David': 86,
         'Ellena': 49
     }
     6-6-1) 读取dict元素
        法一：
             if 'Alice' in d:
                 print(d['Alice']) # ==> 45
        法二：get()  获取指定值
            print(d.get('Alice')) # ==> 45
             ps：当key不存在时，也不会报错，而是返回None
     6-6-2) 添加更新dict元素
            d = {
                'Alice': 45,
                'Bob': 60,
                'Candy': 75,
                'David': 86,
                'Ellena': 49
            }
            d['Mimi'] = 72
            d['Dodo'] = [88, 90]
            d['Dodo'].append(90)
           ps: 当key不存在时，往dict中添加对应的key: value元素。
               当key存在时，会更新dict，用新的value替换原来的value。

     6-6-3) 删除dict元素
          pop() 参数诶制定需要删除的元素的key，并返回对应的value，key不存在时会报错
          keys() 可以返回dict的所有key; d.keys()
          例子：判断指定元素是否存在，若存在则删除
              d = {
                  'Alice': 45,
                  'Bob': 60,
                  'Candy': 75,
                  'David': 86,
                  'Ellena': 49
              }
              name = 'Alice'
              if name in d.keys():
                  d.pop(name)
              else:
                  print('{} not in d'.format(name))

              print(d)

     6-6-4) 特点
            1) key不可变：
                ps: tuple可以作为dict的key，但是list不可以作为dict的key,否则会报错
                    在一个dict汇总，key不能重复
            2) 遍历dict
                法一：
                    for key in d: # 遍历d的key
                        value = d[key]
                        if value > 60:
                            print(key, value)
                # ==> Candy 75
                法二：items() 方法
                    for key, value in d.items():
                        if value > 60:
                            print(key, value)
                    # ==> Candy 75

                例子：一次输出每个同学的每次成绩
                    d = {'Alice': [50, 61, 66], 'Bob': [80, 61, 66], 'Candy': [88, 75, 90]}
                    for key,value in d.items():
                        for score in value:
                            print(key,score);
     6-6-5) 其他方法
            keys() 返回dict汇总所有的key。 d.keys()
            values() 返回dict中所有的value。
                例子：   d = {'Alice': [50, 61, 66], 'Bob': [80, 61, 66], 'Candy': [88, 75, 90]}
                        for key in d.values():
                            print(key)
                        # ==> [50, 61, 66]
                        # ==> [80, 61, 66]
                        # ==> [88, 75, 90]
            clear() 直接清除dict中所有的元素。 d.clear()  #{}
            len()
               d = {'Alice': [50, 61, 66], 'Bob': [80, 61, 66], 'Candy': [88, 75, 90]}
               keys = d.keys()
               print(len(keys))

    6-7) set()
          特点：
            1. 里面的元素是不允许重复的
            2. 里面的元素是没有顺序的
            3. 里面的预算怒是区分大小写的
        6-7-1) 读取set元素
                names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
                name_set = set(names)
                'Alice' in name_set # ==> True  存在则返回true

        6-7-2) 添加set元素
             1. 单个添加 add()
               name_set.add('Alice');
             2. 批量添加  update()

        6-7-3) 删除set元素
              1. remove()  元素不存在时，会报错，因此要先判断是否存在
                 用法：name_set.remove('Jenny')
                例子：
                    L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
                    S = set([1, 3, 5, 7, 9, 11])
                    for n in L:
                        if n in S:
                            S.remove(n)
                        else:
                            S.add(n)
                    print(S)
              2. discard()  不存在时，不会报错
                 用法： name_set.discard('Jenny')

              3. clear() 清除所有元素
                 用法： name_set.clear()
        6-7-4) 集合的相关方法
              1. issubset()  是否为子集
              2. issuperset() 是否为超集
                  例子：
                      s1 = set([1, 2, 3, 4, 5])
                      s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
                      # 判断s1是否为s2的子集
                      s1.issubset(s2) # ==> True
                      # 判断s2是否为s1的超集
                      s2.issuperset(s1) # ==> True
              3. isdisjoint() 判断集合是否重合；有重合，返回False！！！否则返回True！
                  例子：
                    s1 = set([1, 2, 3, 4, 5])
                    s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
                    s1.isdisjoint(s2) # ==> False，因为有重复元素1、2、3、4、5
        6-7-5) 函数
              1. 内置函数
                    len()   求list长度； len(L)
                    abs()   求绝对值； abs(-100)
                    cmp(x,y) 比较两个数的大小； 如果x < y 返回 -1，如果x == y 函数返回0，如果x > y函数返回1
                    int()   将合法的其它类型数据转换为整数
                    str()   将其它类型的数据转换为字符串
              2. 定义函数
                   def my_abs(x):
                       if x >= 0:
                           return x
                       else:
                           return -x

              3. 多个返回值
                    例子：求list的奇数偶数分别的和
                     # coding=utf-8
                     def sub_sum(L):
                         js = [];
                         os = [];
                         for i in L:
                             if i%2==0:
                                 os.append(i)
                             else:
                                 js.append(i)
                         return sum(js),sum(os)

                     res = sub_sum([1,2,3,4]);
                     print('奇数项的和 = {}'.format(res[0]))
                     print('偶数项的和 = {}'.format(res[1]))
              4. 递归函数：自己调用自己的函数
                  例子：分别使用递归和循环，求出1~100的和
                    # coding=utf-8
                    #法一
                    def he(n):
                        if n==1:
                            return 1
                        return n + he(n - 1)
                    print(he(100));
                    #法二
                    def he2(n):
                        sum = 0;
                        i = 1;
                        while i<=n:
                            sum = sum + i
                            i=i+1;
                        return sum

                    print(he2(100));
              5. isinstance() 对函数参数进行校验
                        isinstance(100,int) #==> True
                        isinstance(100,int) #==> False
                    例：
                        def my_abs(x):
                            if not isinstance(x, int) or not isinstance(x, float):
                                print('param type error.')
                                return None
                            if x >= 0:
                                return x
                            else:
                                return -x
               6. 自定义函数默认参数
                    例：
                        def greet(p='world'):
                            res = 'Hello,' + p +'.';
                            return res

                        print(greet('test')); #==》 Hello,world.
               7.自定义函数使用可变参数（可理解成索引数组） *args
                  *args   在使用上，python会把可变参数定义为一个tuple
                  例： 求一组数的平均值，若可变参数长度为0，也能正确返回结果
                    def average(*args):
                        sum = 0
                        if len(args) == 0:
                            return sum
                        for item in args:
                            sum += item
                        avg = sum / len(args)
                        return avg
                    print(average(1, 2))

               8. 自定义函数使用可变关键词参数（可理解成关联数组） **kwargs
                   例：传三个list,分别包含同学的名字、性别和年龄，分别把每个同学的名字、性别和年龄打印出来。
                    def st(**kwargs):
                        names = kwargs['names'];
                        genders = kwargs['gender'];
                        ages = kwargs['age'];
                        index = 0;
                        for name in names:
                            gender = genders[index]
                            age = ages[index]
                            print('name:{},gender:{},age:{}'.format(name,gender,age))
                            index = index+1


                    st(names = ['A','B','C'],gender = ['男','女','男'],age = [1,3,5]);