Python基础学习

by:咕咕咕 6.18

1.python学习：
    什么是python？
        类似java 面向对象编程语言 
    python可以干什么？
        java可以干的 他都可以做，语法比java简单 上手简单    
    python怎么用？
        安装python 勾选 add to path 自动配置环境变量 
        
python 常用方法：
    id() :查看对象的id值 对象一旦被创建是无法更改id值的！
        语法：a = 5 
              id(a)
    print() :输出语句 (python中建议一行代码不超过80个字符 一条语句使用 ‘’ 分开到下一行)
        语法：print(123,'gubin',"古斌")
    type() : 查看对象的类型
    len()  : 查看对象的长度 length        
    max()  :查看最大元素 【数组/多个数字】
    min()  :查看最小元素     【数组/多个数字】
    index() : 查看指定元素出现的第一次索引位置 举例 列表.index("列表中的元素")
    count() : 查看元素出现的次数 举例 列表.count("列表中的元素")
                # 设置要替换的字符
            print("--" * 40)
            # 打印原列表
            print("打印原列表", students)
            name = "gb"
            # 1.查询ww的索引位置
            index = students.index("ww")
            # 2.开始替换
            students[index] = name
            # 打印新的列表
            print("替换之后的列表", students)
            # 打印位置
            print("新元素所在的位置", index + 1)
            # 切片 0 - index
            print("切片 0-index+1", students[0:index + 1])
            # 向列表中末尾添加一个 qe 钱二并执行打印
            students.append("qe")
            print("向列表中末尾添加一个 qe 钱二并执行打印", students)
            # 删除索引为0的元素并执行打印
            del students[0]
            print("删除索引为0的元素并执行打印", students)
            # 添加 'w2' 吴二 索引为1的位置 并执行打印
            students.insert(1, 'w2')
            print("添加所以为1的位置 并执行打印", students)
            # 索引2删除并返回被删除的元素
            print("索引2删除并返回被删除的元素", students.pop(2))
            # 删除lb 并打印
            students.remove("lb")
            print("删除lb 并打印", students)
            # 进行排序
            print(number)
            number.sort(reverse=True)
            print(number)
            # 清空列表 打印
            # students.clear()
            print(students)
            # 遍历序列
            numb = 0
            while numb < len(students):
                print(students[numb])
                numb += 1
            print("*" * 20)
            # for 循环遍历
            for lists in students:
                print(lists)

特点说明：
        1):    Python是一个动态语言 他不像java需要有String int boolean 这些关键字 他可以对一个变量
            随意赋值 a = 1   a = 'zs' a = False
        2):    Python中的命名规则 : 只能包含 字母 数字 下划线 并且不能数字开头,Python有两种命名规则
             1下划线命名法：所有的字母小写 单词之间使用 下划线区分
             2.帕斯卡命名法：首字母大写，每个单词开头字母大写 其他字字母小写

        3): Python中的类型：
                Python中虽然不需要类型(String,int...)规定但是还是有自己的一套格式
                    # 在Python数值分成了三种：整数、浮点数（小数）、复数
                        ***在python所有的整数都是int类型 没有长度要求 可以用 _ 作为分隔符
                                a = 999999999999999999999
                                a = 9999999999_999999_99999
                                正常输出,不影响
                        ***在Python中 数字 加 字符串 会报错    ;10进制数字不能以0开头复制
                        ***在Python中 二进制0b开头 八进制0o开头 十六进制0x开头    
                        ***在Python中所有浮点数都是 float类型(对浮点数进行运算时，可能会得到一个不精确的结果)
                        ***        Python中的注释
                                        #  单行注释
                                        ''' 多行注释 '''
        4):Python中的格式化字符串
                字符串的占位符 使用 %
                                    %s 代表字符串占位符
                                    %3.5s 代表3至5个字符串
                                    %f 代表浮点站位符号
                                    %.2f 代表接受数字后的两位 并四舍五入 12.123 打印12.12 ；12.456 打印 12.46
                                    %d 代表接受整数
                                举例:
                                    a = "hello %s" % "zs"
                                        print(a)
                                            : hello zs
                                    a = "hello %s 你好 %s" % ("zs","ls")
                                        print(a)
                                            : hello zs 你好 ls
                                    a = "show : %3.5s" % "gubinlalala"
                                        print(a)    
                                            : show: gubin
                                    a = "show float: %f" % 123.123
                                        print(a)
                                            : show float: 123.123
                                    a = "show float: %.2f" % 123.456
                                        print(a)
                                            : show float:     123.46 (会进行四舍五入 并显示小数后的2位)    
                                    a = "show number: %d" %    123456.33
                                        print(a)
                                            : show number: 123456  (会显示整数 不会进行四舍五入)
                "字符串与数字的拼接"
                                将数字变量"添加到字符串中显示"
                                    举例：a = 10; 
                                            print(f'a的值是{a}')
                                                : a的值是10
        5）字符进行乘法运算  会将字符串 * 被乘数 遍 （可以使用制表符）
                                举例
                                    a = "show"
                                        print(a * 5 )
                                            ：showshowshowshowshow
                                    a = "show	"
                                        print(a * 5)    
                                            :show show show show show
        6）Python中的 True 与 False 与 None
                                Python中 True 等于 1 False 等于 0
                                None代表空值
        7) Python中的类型 使用(type() 方法查看)
                                a = 123   :<class 'int'>
                                b = 123.1 :<class 'float'>
                                c = True  :<class 'bool'>
                                d = "123" :<class 'str'>                
                                e = None  :<class 'NoneType'>
                                f = []    :<class 'list'> 列表    
                                g = {}    :<class 'dict'> 元组
                                h = ()    :<class 'tuple'>字典
                                i = {}    ：<class 'set'> 集合 
        8)# 算术运算符
                     + 加法运算符（如果是两个字符串之间进行加法运算，则会进行拼串操作）
                     - 减法运算符
                     * 乘法运算符（如果将字符串和数字相乘，则会对字符串进行复制操作，将字符串重复指定次数）
                     / 除法运算符，运算时结果总会返回一个浮点类型
                     // 整除，只会保留计算后的整数位，总会返回一个整型
                     ** 幂运算，求一个值的几次幂
                     % 取模，求两个数相除的余数                            
        9)# 赋值运算符
                     = 可以将等号右侧的值赋值给等号左侧的变量
                     +=  a += 5 相当于 a = a + 5 
                     -=  a -= 5 相当于 a = a - 5 
                     *=  a *= 5 相当于 a = a * 5 
                     **= a **= 5 相当于 a = a ** 5 
                     /=  a /= 5 相当于 a = a / 5 
                     //= a //= 5 相当于 a = a // 5 
                     %=  a %= 5 相当于 a = a % 5         
        10) # 关系运算符
                     关系运算符用来比较两个值之间的关系，总会返回一个布尔值
                     如果关系成立，返回True，否则返回False
                     > 比较左侧值是否大于右侧值
                     >= 比较左侧的值是否大于或等于右侧的值
                     < 比较左侧值是否小于右侧值
                     <= 比较左侧的值是否小于或等于右侧的值
                     == 比较两个对象的值是否相等
                     != 比较两个对象的值是否不相等
                       (相等和不等比较的是对象的值，而不是id)
                     is 比较两个对象是否是同一个对象，比较的是对象的id
                     is not 比较两个对象是否不是同一个对象，比较的是对象的id
                     Python中支持连续比较 比如 result a>b>c
        11) 三元用算符
                    语句1 if  条件 else 语句2
                        a = True
                        print("真") if a else print("假")  #输出真
        12) 流程控制：
            if判断
                            if 条件1:
                                语句1
                            elif:
                                语句2    
                            else:
                                语句3
            input()输入：
                        username = input("请输入用名")
                        if username == "zs":
                            print("输入正确")
                        else:
                            print("输入错误")
            while
                        i = 0
                        while i < 10:
                            i += 1
                            print("i=", i)
                        else:
                            print("else代码块")
        13) 容器：
                第一个 列表 （java中数组）    
                    创建：
                        arr = []
                        它可以存取任何数据，下标从0开始，有序，print(arr) 直接打印出该 列表所有元素 类似于 java的toString!不可以下标越界！
                        stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
                        stus[2] 打印沙和尚
                        stus[-1] 打印白骨精  (也就是说 从后往前获取 就是负数获取 下标从-1开始，正着获取下标就是从0开始)
            切片：
                切片指从现有列表中，获取一个子列表
                    语法：列表[起始:结束:步长] # 步长不能是0，但是可以是负数
                    stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
                    print(stus[0:5:3]) 也就是:['孙悟空','唐僧']
                            从0索引开始 到5索引结束 但是不包括5索引 每隔三个截取一个
                    print(stus[1:])   如果省略结束位置，则会一直截取到最后
                     print(stus[:3])   如果省略起始位置，则会从第一个元素开始截取
                     print(stus[:])    如果起始位置和结束位置全部省略，则相当于创建了一个列表的副本
            通用操作： + 和 *
                
                 +可以将两个列表拼接为一个列表
                    my_list = [1,2,3] + [4,5,6]

                 * 可以将列表重复指定的次数
                    my_list = [1,2,3] * 5    
                    
            判断该元素是否存在于该 列表中    ：使用 语法: '元素' [not] in 列表
                    # 创建一个列表
                        stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚']
                    print('孙悟空' in stus) :True
                    print('孙悟空' not in stus) :False
                    #创建列表
                        numbers = [1,5,6,9,10,66,5]
                        print(max(numbers)) 打印66
                        print(min(numbers)) 打印1
            元组 
                    元组跟列表是一样的 它出现的目的就是 元组中的数据不可以被改变
                        语法 ：my——tuple = () 
                            元组是不可变对象;如果元组不是空的括号可以省略,如果必须要用括号 数据后面必须有 , 
                            删除不可以删除单一的元素 只能将此元组删除掉
                            # 定义元组
                                my_tuple = ()
                                print("这是一个空的元组", my_tuple)
                                my_tuple = (2, 1,)
                                print("如果最后不带， 会报语法错误，但是不影响数据", my_tuple)
                                my_tuple = 1, 2, 3, 6, 5
                                print("不使用括号", my_tuple)
            解包：在对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致
                # 元组中的解包 将元组中的数据 赋值给变量 (将元组看成数据) ps： 解包不只是元组中使用
                    my_tuple = "zs", "ls", "ww", "zl"
                    print("未解包：", my_tuple)
                    # 执行解包 将数据依次赋值给 abcd 四个变量
                    a, b, c, d = my_tuple
                    # 打印这些变量的值
                    print(a, b, c, d) ：zs ls ww zl
                    # 普通的解包 将 a b 的值交换
                    a = 100
                    b = 200
                    print("未解包：","a:",a,"b",b)：未解包： a: 100 b 200
                    a,b = b,a                      ：解包：a=200,b=100
                        
                    print(f"解包：a={a},b={b}")
                    #总结
                        #1.在对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致        
                        #2 不过可以使用 * 来接受剩下的值：(一条语句中不允许出现多个 * 只能是最后一个字符可以带有 * )
                                    # 定义一个 元组
                                        my_tuple = 10, 20, 30, 40
                                        # 开始解包
                                        a, b, *c = my_tuple
                                        print("解包后的数据：",a,b,c)  ：解包后的数据： 10 20 [30, 40]
            可变对象：
                        # == !=  is is not
                        # == != 比较的是对象的值是否相等 
                        # is is not 比较的是对象的id是否相等（比较两个对象是否是同一个对象）        
                    a = [1,2,3]
                    b = [1,2,3]
                    print(a,b)
                    print(id(a),id(b))
                    print(a == b) # a和b的值相等，使用==会返回True
                    print(a is b) # a和b不是同一个对象，内存地址不同，使用is会返回False        
            字典：
                    这个字典呢，跟json非常的相似，字典也是用来存数据的 ,跟json的格式一模一样
                        语法：a = {} 创建一个空的字典
                              {key:value,key:value...}
                              字典的值(value)是任意的对象 ,键是不可重复的,    如果出现重复的后边的会替换到前边的
                            student = {"name":'zs',"age":18,"sex":'男'}    
                        获取字典中的值
                            print(student["name"])  # 打印zs
                            print(student("ss"))  # 如果键不存在 TypeError: 'dict' object is not callable
                        使用dict()函数创建字典
                        # 每个参数都是一个键值对参数名就是键，参数名就是值（这种方式创建的字典，key都是字符串）
                            dicts = dict(name="zs", age=8)  
                            print(dicts) 打印 {'name': 'zs', 'age': 8}
                        # 也可以将一个包含有双值子序列的序列转换为字典  如果序列是单数 那么将报错
                            dicts = dict([(1, 2), (3, 5)])  
                                print(dicts) 打印 {1: 2, 3: 5}
                        # len() 获取字典中键值对的个数
                        # print(len(dicts)) ：2
                        # in 检查字典中是否包含指定的键
                        # not in 检查字典中是否不包含指定的键
                        # 通过[]来获取值时，如果键不存在，会抛出异常 KeyError
                        # get(key[, default]) 该方法用来根据键来获取字典中的值
                                dicts.get("name") 打印zs
                        #   如果获取的键在字典中不存在，会返回None
                        #   也可以指定一个默认值，来作为第二个参数，这样获取不到值时将会返回默认值
                        # print(d.get('name'))
                        # print(d.get('hello','默认值'))
                        student = {
                            "name": 'zs',
                            "age": 18,
                            "sex": '男'
                        }
                        print(student.get("name"))  # 返回zs
                        print(student.get("ss", "不存在"))  # 第二个参数设置默认值 如果不存在就返回默认值
                        
                        # 修改字典
                        # d[key] = value 如果key存在则覆盖，不存在则添加
                        student['name'] = 'sunwukong'  # 修改字典的key-value
                        student['address'] = '花果山'  # 向字典中添加key-value
                        print(student)  # {'name': 'sunwukong', 'age': 18, 'sex': '男', 'address': '花果山'}
                        # setdefault(key[, default]) 可以用来向字典中添加key-value
                        #   如果key已经存在于字典中，则返回key的值，不会对字典做任何操作
                        #   如果key不存在，则向字典中添加这个key，并设置value
                        result = student.setdefault("name", "猪八戒")
                        print(result)  # 返回原有的孙悟空
                        result = student.setdefault("isPerson", "No")
                        print(result)  # 设置 并返回值
                        print(student)
                        # update([other])
                        # 将其他的字典中的key-value添加到当前字典中
                        # 如果有重复的key，则后边的会替换到当前的
                        d = {'a': 1, 'b': 2, 'c': 3}  # {'a': 7, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
                        d2 = {'d': 4, 'e': 5, 'f': 6, 'a': 7}
                        d.update(d2)
                        print(d)
                        # 删除 删除键 Value 将会同样的删除
                        d = {'a': 1, 'b': 2, 'c': 3}  # {'b':2,'c':3}
                        del d["a"]
                        print(d)
                        # popitem()
                        # 随机删除字典中的一个键值对，一般都会删除最后一个键值对
                        #   删除之后，它会将删除的key-value作为返回值返回
                        #   返回的是一个元组，元组中有两个元素，第一个元素是删除的key，第二个是删除的value
                        # 当使用popitem()删除一个空字典时，会抛出异常 KeyError: 'popitem(): dictionary is empty'
                        result = d.popitem()
                        print(result)
                        # clear()用来清空字典
                        d.clear()
                        # pop(key[, default])
                        # 根据key删除字典中的key-value
                        # 会将被删除的value返回！
                        # 如果删除不存在的key，会抛出异常
                        #   如果指定了默认值，再删除不存在的key时，不会报错，而是直接返回默认值
                        result = d.pop('d', "bucuoza")
                        result = d.pop('z', '这是默认值')

                        # copy()
                        # 该方法用于对字典进行浅复制
                        # 复制以后的对象，和原对象是独立，修改一个不会影响另一个
                        # 注意，浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制
                        print("-" * 20)
                        a = {'a': 1, 'b': 2, 'c': 3}
                        b = a.copy()
                        print(a)
                        a = {"name":1}
                        print(a)
                        print(b)
                        # 创建集合
                        sets = {10, 20, 30, 40}
                        # 遍历集合
                        print(sets)  # 打印{40, 10, 20, 30} 因为是Set集合 没有顺序
                        # 创建空集合
                        set2 = ()
                        print(set2)  # 只会打印一个 （）
                        # 使用Set() 创建集合
                        setlist = set('hello')  # 打印 {'l', 'o', 'h', 'e'}
                        print(setlist)
                        # 判断
                        sets = {10, 20, 30, 40}
                        print(10 in sets)  # 打印True
                        print(10 not in sets)  # 打印False
                        # 查看len
                        print(len(sets))  # 打印4
                        # 使用Update 1将一个集合中的元素添加到当前集合中2. update()可以传递序列或字典作为参数，字典只会使用键
                        set01 = {10, 20, 30, 40}
                        set02 = set('hello')
                        set01.update(set02)  # 将set02集合中的值存到 set01中
                        print(set01)  # {40, 10, 'o', 20, 'l', 'e', 'h', 30}
                        set01.update([(1, 2, 3)])
                        print(set01)  # {40, 10, (1, 2, 3), 'o', 20, 'l', 'e', 'h', 30}
                        # pop() 随机删除并返回
                        print(set01.pop())
                        # remove()删除集合中的指定元素
                        # set01.remove('o')
                        print(set01)
                        # clear 清空集合
                        # set01.clear()
                        # print(set01)
                        # copy
                        oo = set01.copy()
                        print(oo)
                        print(type(set01))

                        #  集合的运算
                        a = {1, 2, 3}
                        b = {3, 4, 5, 6, 7}
                        # 交集运算   (将相同的数据拿出来)
                        print(a & b)  # {3}
                        # 并集运算 (所有数据和到一起 去重)
                        print(a | b)  # {1,2,3,4,5,6,7}
                        # 差集 （a中有b中没有的数据）
                        print(a - b)  # {1,2}
                        # 异或集 （两个集合中 不重复的数据）
                        print(a ^ b)  # {1,2,4,5,6,7}

                        # 重新定义集合
                        a = {1, 2, 3, 4}
                        b = {1, 2, 3, 4, 5, 6}
                        # 子集 与 超集  如果 a中的数据在b中全部出现 那么就可以说 ： a 是 b 的子集 b是a的超集
                        print(a <= b)
                        # 真子集 与 真超集 如果 a中的数据 在b中全部存在并且b中还有a中没有的数据 那么 a就是b的真子集 b就是a的真超集
                        print(a < b)
                            













    
    













    练习的小Demo
            01.打印： 你好 xxx 啦啦啦！ 使用四种方式:
                #定义变量
                name = "zs"
                #定义打印语句
                print("你好"+name+"啦啦啦")
                    ：你好zs啦啦啦
                print(f"你好{name}啦啦啦")
                    ：你好zs啦啦啦
                print("你好",name,"啦啦啦")        
                    ：你好 zs 啦啦啦  (打印语句的时候会有空格)
                print("你好%s啦啦啦" % name)
                    :你好zs啦啦啦
            02. 字符的加密
                from urllib.parse import quote, unquote

                name = "古斌"
                # 编码
                utf8_name = quote(name)
                # utf-8
                print(utf8_name)
                # %E5%8F%A4%E6%96%8C   长度是 9
                gbk_name = quote(name, encoding="gbk")
                print(gbk_name)
                # %B9%C5%B1%F3    长度是 6
                #  解码
                print(unquote(utf8_name))
                print(unquote(gbk_name, encoding="gbk"))
            03 判断三个数那个最大
                        a = 9
                        b = 5
                        c = 36
                        max = a if a > b else b
                        max = c if c > max else max
                        print(max)
            04 1为男 0为女 其他为人妖  (因为input() 接受的数据都是字符串 所以需要强转)
                        sex = int(input("请输入你的性别："))
                        if sex == 0 :
                            print("你是个小姐姐")
                        elif sex == 1:
                            print("你是小哥哥")
                        else:
                            print("你是人妖")
            05 员工信息管理
                            # 创建死循环 循环数据
                            # 初始化员工
                            emps = ["张三,20,java"]
                            while True:
                                # 初始化公告栏
                                print("-" * 20, "欢迎来到员工管理系统", "-" * 20)
                                # 打印语句
                                print(f"---》》 初始化员工状态成功..当前员工个数为{len(emps)}人")
                                # 执行选择项
                                print("请选择您的操作：")
                                print("1:查看员工
2.添加员工
3.删除员工
4.退出系统")
                                # 创建输入
                                select = int(input("请选择编号："))
                                # 判断用户的输入
                                if select == 1:
                                    print(f"当前的员工有：{emps},共 {len(emps)} 人！")
                                elif select == 2:
                                    # 获取用户输入
                                    emp_info = input("请依次输入员工姓名，年龄，专业:并且用逗号分开：")
                                    # 使用append添加数据
                                    emps.append(emp_info)
                                    # 打印数据
                                    print(emps)
                                elif select == 3:
                                    boo = True
                                    while boo:
                                        empNumber = int(input("请输入要删除的员工的序号："))
                                        if empNumber is None:  # 如果需要为空
                                            print("输入不能为空")
                                        elif empNumber < 0 or empNumber > len(emps):  # 如果下标越界
                                            print("序号不合法")
                                        else:
                                            del emps[empNumber]  # 执行删除
                                            if len(emps) > 0:
                                                if_del = input(f"删除成功现在有{len(emps)}位员工！是否继续删除？Y/N")
                                                if if_del == 'Y':
                                                    boo
                                                else:
                                                    print("程序退出")
                                                    boo = False
                                                    break
                                            else:
                                                print("员工个数为0。。程序退出..")
                                                break
                                elif select == 4:
                                    print("欢迎下次使用")
                                    break
            06# 键盘输入判断是否存在
                                '''
                                # 创建键盘输入
                                query_name = input("请输入你要查询人的姓名:")
                                # 判断用户输入的 name 是否存在于列表中
                                if query_name in students:
                                    # 如果存在
                                    print(f"{query_name},存在于【students】列表中，他存在于{students.index(query_name)+1}的位置")
                                else:
                                    # 不存在
                                    print(f"{query_name}不存在于列表中")
                                print("*" * 40)
                                '''