zoukankan      html  css  js  c++  java
  • python基础

    一、python简介

    • python是由荷兰人Guido van Rossum于1989发明,第一个公开发行版本于1991年。python是一门解释型语言,开发效率高,但是运行速度相对较慢。
    • python是弱类型语言,具有简洁,优雅,清晰的特点。
    • python的应用领域:科学计算、人工智能、网络爬虫、图形界面、web开发等。
    • python安装

      官网:www.python.org

      安装和环境配置教程:https://jingyan.baidu.com/article/c45ad29c05c208051653e270.html

    • python之变量

      命名规则

        1.必须使用英文字母,数字,下划线组成

        2.不能使用数字作为开头,更不能是纯数字

        3.禁止使用关键字作为变量名

        4.不要太长

        5.区分大小写

        6.不要使用中文作为变量名

        7.要有意义

        8.推荐使用驼峰和下划线变量名

    二、数据类型

    • int整型)可做加,减,乘,除,取余,取整运算(+,-,*,/,%,//) 主要用来进行数学运算
    • str字符型) 字符拼接(+) 重复(*) ; " ",' ',''' ''',""" """ 都是字符串      存储少量的数据
    • bool(布尔型)  True为真,False为假     用于判断真假   True, False
    • dict  (字典)        一对一对的存储数据. key:value {"  ":"  ","  ":"  "}
    • list  (列表)      存取大量数据
    • tuple元组)     只读列表, 不能改( )
    • set  (集合)      存储不重复的内容

    查看数据类型

    a=2
    print(type(a))

    >>> int

     数据运算

    a=1
    b=2
    c=a+b
    print(c)

    >>> 3

    字符串拼接

    s1 = "sylar"
    s2 = "wusir"
    s3 = "alex"
    
    s4 = s1 + s2 + s3    # 字符串拼接(连接)
    print(s4)

    >>> "sylarwusiralex"

    重复

    s = "考试
    "    
    
    print(s*3)    # s 重复 3次

    >>> 考试

      考试

      考试

    三、运算符

    • 运算可分为:算数运算,比较运算,逻辑运算,赋值运算,成员运算,身份运算,位运算.
      • 算数运算
        • 运算符: '+' , '-' ,'*' , '/' , '%' ,'//' , '**'  ( 依次为 加 减 乘 除 取余 取整 次幂)
      • 比较运算
        • 运算符: '==' , '!=' , '<>' , '>' , '<' , '>=' , '<=' (依次为 等于 不等于 不等于 大于 小于 大于等于 小于等于) 
      • 赋值运算
        • 运算符: '=' , '+=' , '-=' , '*=' , '/=' , '**=' , '//=' , '%=' 
      • 逻辑运算:
        • 运算符: 'and' , 'or' , 'not'
        • and: 并且的意思. 左右两端的值必须都是真. 运算结果才是真
        • or或者的意思. 左右两端有一个是真的. 结果就是真. 全部是假. 结果才能是假
        • not非的意思. 原来是假. 现在是真.  非真即假, 非假既真

    逻辑运算优先级: () > not > and > or

    判断下列列逻辑语句句的True,False.

    3>4 or 4<3 and 1==1
     
    1 < 2 and 3 < 4 or 1>2
     
    2 > 1 and 3 < 4 or 4 > 5 and 2 < 1
     
    1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8
     
    1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6
     
    not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6

    >>>>运算结果依次为:False ,  True ,  True ,  False ,   False ,   False

    第二种运算方法:

           x or y , x为真,值就是x,x为假,值是y         

             x and y, x为真,值是y,x为假,值是x

    判断下列逻辑语句

    print(0 or 1 or 3 or 0 or 5)    
    print(1 and 2)  
    print(2 and 0)  
    print(0 and 3)  
    print(0 and 4)  
    
    print(0 or 4 and  3 or 7 or 9 and  6)
    
    print(2 > 3 and 3)      
    print(2 < 1 and 4 > 6 or 3 and 4 > 5 or 6)

    >>>>>>>运算结果依次为: 1 ,  2 ,  0 ,   0 ,  0 ,  3 ,  0 ,  6

     四、if条件判断、while循环、for循环

    • while循环

        基本用法:

          while 条件:

            代码块1

          else:

            代码块2

    运行流程:1)当条件成立时,执行代码块1

         2)再次判断条件是否为真,如果为真,再次执行代码块1.......

         3)当条件为假.执行else 跳出循环. 循环结束

    1.使用while循环输出1-10的整数

    i=1
    while i<=10:
        print(i)

    2.输出1-100所有整数的和

    i=1
    sum =0
    while i<=100:
        sum=sum+i
        i+=1
    print(i)

    3.输出1-100内的所有奇数

    num = 1 
    while num <= 100:
        if num % 2 != 0:
            print(num)
        num += 1

    4.猜数字小游戏

    count = 3
    num =66
    while count >= 1:
        guess = input("请输入一个数字:")
        if guess == num:
            print("猜测结果正确")
            break
        elif guess > num:
            print("猜测结果大了")
        else:
            print("猜测结果小了")
            
        count -= 1
    else:
        print("太笨了你.....")

    5.求1-2+3-4+5....99的所有数的和.

     1 start = 1
     2 sum = 0
     3 while start <100:
     4     temp = start % 2
     5     if temp ==1:
     6         sum = sum + start
     7     else:
     8         sum = sum - start
     9     start += 1
    10 print(sum)
    View Code

    6.输入一个数,判断这个数是几位数(用算法实现)

    1 1 count = 1
    2 2 num = int(input("请输入一个数字:"))
    3 3 while True:
    4 4     num = num / 10
    5 5     if num < 10:
    6 6         break
    7 7         
    8 8     count += 2
    9 9 print(count)
    View Code
    • 格式化输出

      • %s: 字符串的占位符, 可以放置任何内容(数字)

      • %d: 数字的占位符

    1.字符串占位符示例

    1 name = input("请输入名字:")
    2 age = input("请输入你的年龄:")
    3 hobby = input("输入你的爱好:")
    4 gender = input("请输入你的性别:")
    5 
    6 print("%s今年%s岁, 是一个老头, 爱好是%s, 性别:%s" % (name, age, hobby, gender))

    2.数字占位符示例

    a = 108
    s = "梁山水泊有%d个厉害的人物" % (a)
    print(s)

    >>>>小提示:如果字符串中有了占位符. 那么后面的所有的%都是占位. 需要转义;如果这句话中没有占位符. %还是%

     break   结束循环. 停止当前本层循环
     continue  结束当前本次循环. 继续执行下一次循环

    • 用户交互(input)

    变量 = input("提示语:")  变量是字符串类型 ,字符串=> 数字    => int(str)

    count = input("请输入你要玩的次数:")
    print(count)

    >>>请输入你要玩的次数:3

    >>> 3

    #程序执行,未输入数字时,程序为阻塞状态

    • if判断语句

        if语句基本用法

          if 条件判断:

            代码块

          运行流程:当条件成立,执行代码块

          if 条件1:

            代码块1

          elif 条件2:

            代码块2

          else:

            代码块n

          运行流程:当条件1成立,执行代码块1;如果条件1不成立,条件2成立,则执行代码块2;如果所有条件都不成立,则执行代码块n

     1.用户登录

    user=input("enter your username:")
    password=input("enter your password:")
    if user=="liqing" and password=="123456":
        print("登录成功")
    else:
        print("用户名或密码错误")

    >>>>>>>>> 如果输入的user为"liqing",并且password为"123456",则会打印登录成功,否则打印用户名或密码错误。

    2.猜年龄

    import random
    age=random.randint(1,10)
    guess=int(input("enter number(1-10):"))
    if guess==age:
        print("恭喜你猜对了t")
    elseprint("对不起,你猜错了")

    >>>>>>>>>>>import random  #导入内置函数  random为随机数函数

    >>>>>>>>>>>age=random.randint(1,10)  #随机生成一个1到10的整数,并赋值给age

    >>>>>>>>>>>输入一个数字(范围1-10),如果输入的数字与生成的随机数相同,打印恭喜你猜对了,否则打印对不起,你猜错了。

    • 迭代

                    for 变量 in 可迭代对象:
                        循环体
                    else:

     1 s19 = "大家好, 我是VUE, 前端的小朋友们. 你们好么?" 
     2 
     3 # 用while循环 
     4 
     5 index = 0 
     6 while index < len(s19):
     7     print(s19[index])   # 利用索引切片来完成字符的查找
     8     index = index + 1
     9 
    10 # for循环, 把s19中的每一个字符拿出来赋值给前面的c 
    11 
    12 for c in s19:
    13     print(c)
    • range

        range介绍:

         作用:数数

         有一个参数:结束为止
              两个参数: 1. 起始位置, 2.结束位置
              三个参数: 1. 起始位置, 2. 结束位置. 3.步长

    range基本应用:

     1 #range() 应用:
     2 for i in range(10): # 从0开始. 到10结束
     3     print(i)
     4 
     5 for i in range(3, 7):   # 从3 开始. 打印到7结束. 不能到7
     6     print(i)
     7 
     8 for i in range(3, 10, 2):  # 从3 到 10 每2个取一个
     9     print(i)
    10 
    11 for i in range(10, -10, -1):  #从10 开始到-10结束. 倒着数
    12     print(i)

    计算:

    1 # 求1-2+3-4...+99-100=?
    2 sum = 0
    3 for i in range(1, 101):
    4     if i % 2 == 0:
    5         sum = sum - i
    6     else:
    7         sum = sum + i
    8 print(sum)

      

    五、字符串、列表、元组、字典、集合操作

    • int bool str 概述

      int 方法操作:
                bit_length()    求二进制长度

           bool: 类型转换
                1. 你想转换成什么. 就用什么把目标包裹起来
                2. 带空的是False, 不带空的True

           str:str索引和切片

        索引:起始下标是0(从左到右), (-1)从右到左

     1 s1 = "python⽜B"
     2 print(s1[0])    # 获取第0个 
     3 print(s1[1]) 
     4 print(s1[2]) 
     5 print(s1[3]) 
     6 print(s1[4]) 
     7 print(s1[5]) 
     8 print(s1[6]) 
     9 print(s1[7]) 
    10 print(s1[8])    # 
    11 print(s1[9])    # 没有9, 越界了了. 会报错 print(s1[-1])   # -1 表示倒数. print(s1[-2])   # 倒数第二个
    • 切片: s[起始位置: 结束位置: 步长]     步长: 如果是整数, 则从左往右取. 如果是负数. 则从右往左取. 默认是1
      • 特点:顾头不顾尾
     1 s2 = "python⽜牛B"
     2 print(s2[0:3])  # 从0获取到3. 不包含3. 结果: pyt 
     3 print(s2[6:8])  # 结果 ⽜ 
     4 print(s2[6:9])  # 大是8. 但根据顾头不顾腚, 想要取到8必须给9 
     5 print(s2[6:10])  # 如果右边已经过了大值. 相当于获取到后 
     6 print(s2[4:])   # 如果想获取到后. 那么后⼀个值可以不给. 
     7 print(s2[-1:-5])    # 从-1 获取到 -5 这样是获取不到任何结果的. 从-1向右数. 你怎么数 也数不到-5 
     8 print(s2[-5:-1])    # ⽜b, 取到数据了了. 但是. 顾头不顾腚. 怎么取后⼀个呢? print(s2[-5:])  # 什么都不写就是后了 
     9 print(s2[:-1])  # 这个是取到倒数第⼀个 
    10 print(s2[:])    # 原样输出
    • 字符串的常用操作: 常用方法

        原字符串不可变.

      • upper()          转换成大写
    1 # 应用, 校验用户输入的验证码是否合法 
    2 verify_code = "abDe" 
    3 user_verify_code = input("请输⼊入验证码:") 
    4 if verify_code.upper() == user_verify_code.upper():    
    5     print("验证成功") 
    6 else:    
    7     print("验证失败")
      • strip()            去掉空格
    1 # 应用, 模拟用户登录. 忽略用户输入的空格
    2 username = input("请输入用户名:").strip() 
    3 password = input("请输入密码: ").strip() 
    4 if username == 'alex' and password == '123':
    5     print("登录成功") 
    6 else:
    7     print("登录失败")
      • replace()       替换
    1 # 字符串替换 
    2 s8 = "sylar_alex_taibai_wusir_eggon" 
    3 ret = s8.replace('alex', '金角⼤王')    # 把alex替换成金角大王 
    4 print(ret)  # sylar_金角⼤大王_taibai_wusir_eggon
      • split()            切割
    1 # 字符串切割 
    2 s9 = "alex,wusir,sylar,taibai,eggon" 
    3 lst = s9.split(",")     # 字符串切割, 根据,进行切割 
    4 print(lst)
      • format()        格式化输出
    # 格式化输出 
    s12 = "我叫%s, 今年%d岁了, 我喜欢%s" % ('sylar', 18, '周杰伦')  # 之前的写法 print(s12) 
    s12 = "我叫{}, 今年{}岁了, 我喜欢{}".format("周杰伦", 28, "周润发")    # 按位置格式化 
    print(s12) 
    s12 = "我叫{0}, 今年{2}岁了, 我喜欢{1}".format("周杰伦", "周润发", 28)     # 指定位置 
    print(s12) 
    s12 = "我叫{name}, 今年{age}岁了, 我喜欢{singer}".format(name="周杰伦", singer="周润发", age=28)     # 指定关键字 print(s12)
      • startswith()  判断是否以xxx开头
    1 s13 = "我叫sylar, 我喜欢python, java, c等编程语言." 
    2 ret1 = s13.startswith("sylar")   # 判断是否以sylar开头 
    3 print(ret1) 
    4 ret2 = s13.startswith("我叫sylar")    # 判断是否以我叫sylar开头 
    5 print(ret2)
      • find()           查找. 找不到返回-1
    1 ret5 = s13.find("sylar")    # 查找'sylar'出现的位置 
    2 print(ret5)
    3 ret6 = s13.find("tory")     # 查找'tory'的位置, 如果没有返回-1 
    4 print(ret6)
    5 ret7 = s13.find("a", 8, 22)  # 切片找 
    6 print(ret7)
      • len()           内置函数. 直接使用. 不用点操作 求字符串的长度
    s18 = "我是你的眼, 我也是a" 
    ret = len(s18)  # 计算字符串的长度 
    print(ret)
    • 基础数据类型补充

        str.join()  : 把列表变成字符串,遍历列表,依次把str插入到遍历的列表值末尾中,组成一个新的字符串

    1 b = "&"
    2 c = b.join(['gailun', 'zhaoxin', 'huangzi', 'manzi', 'jiansheng'])
    3 print(c)

    >>>>>>>>> gailun&zhaoxin&huangzi&manzi&jiansheng

      列表在循环的时候不能被删除,因为索引会被改变

    1 lst = ['that girl', 'firs', 'smile of her', 'my dream']
    2 for i in lst:
    3     lst.remove(i)
    4 print(lst)

    >>>>>>>>>['firs', 'my dream']

      结果显示列表并没有被删除干净,是因为列表循环时,指针会第一个指向索引为0的元素,当索引为0的元素被删除后,索引为1的元素会自动向前进一步,索引变成0,而指针再次寻找时,会指向索引为1的元素,所以原先索引为1的元素会被漏掉,从而导致列表删不干净

    1 lst = ['that girl', 'firs', 'smile of her', 'my dream']
    2 lst1 = []
    3 for i in lst:
    4     lst1.append(i)
    5 for i in lst1:
    6     lst.remove(i)
    7 print(lst)

    >>>>>>>>>> [ ]

      用一个新列表来记录原列表元素,然后循环新列表来删除原列表的元素  

          

      也可以用以下方法来循环删除元素

    1 li = ['abc', 'bcd', 'cde', 'edf']
    2 for i in range(0, len(li)):    # 循环len(li)次, 然后从后往前删除
    3     li.pop()
    4 print(li)

    >>>>>>>>>> [ ]

      注意: 由于删除元素会导致元素的索引改变, 所以容易出现问题. 尽量不要再循环中直接去删 除元素. 可以把要删除的元素添加到另一个集合中然后再批量删除.

      字典也不能在循环的时候更改大小,如果想要删除字典中的元素,需要使用一个列表来记录要删除的元素,然后遍历列表来删除字典中的元素

    1 dic = {'yang': 25, 'pan': 24, 'liu': 21}
    2 lst =[]
    3 for k in dic:
    4     lst.append(k)
    5 for i in lst:
    6     del dic[i]
    7 print(dic)

    >>>>>>>>>> { }

      fromkeys()  :  可以通过列表来创建一个字典

    1 s = dict.fromkeys(['林俊杰', '陈奕迅', '周杰伦', '黄家驹'], 'shuai')
    2 print(s)

    >>>>>>>>> {'林俊杰': 'shuai', '陈奕迅': 'shuai', '周杰伦': 'shuai', '黄家驹': 'shuai'}

      也可以通过字典的对象来创建

    1 dic = {}
    2 s = dic.fromkeys(['林俊杰', '陈奕迅', '周杰伦', '黄家驹'], 'shuai')
    3 print(s)

    >>>>>>>>> {'林俊杰': 'shuai', '陈奕迅': 'shuai', '周杰伦': 'shuai', '黄家驹': 'shuai'}

    • 列表的介绍:

      • 表现形式:[ ],列表可以放大量数据,不限制数据类型,里边的内容用逗号隔开.
      • 列表和字符串一样也有索引和切片
    • 常用功能:

        增:

           append(): 给列表追加元素,添加的元素放在列表末尾

             insert(index,object): 把元素插入到列表的index位置,涉及到元素的移动

             extend(): 迭代添加,括号里可以是字符串也可以是一个列表,将字符串或列表里的每一个元素依次添加到原列表的末尾

    • append():
    1 lst = ["周杰伦", "王力宏", "周润发"]
    2 lst.append("伍佰")    # 向列表中添加一个元素, 元素放在末尾. 把一个元素追加到列表的末尾
    3 print(lst)
    • insert():
    1 lst = ["周杰伦", "王力宏", "周润发"]
    2 lst.insert(1, "马化腾")    # 把元素插入到指定位置. 元素的移动
    3 print(lst)
    • extend():
    1 lst = ["周杰伦", "王力宏", "周润发"]
    2 lst.extend(["马云", "王健林", "李嘉诚"])    # 迭代添加
    3 print(lst)

        删:

          pop(): 删除列表的最后一个元素,可以用一个变量来接受被删除的元素

          pop(index): 删除列表index位置的元素

          remove(object): 删除指定元素,但只删除列表的第一个指定元素,其余的不删

          clear(): 清除列表里的全部元素,使之变成一个空列表

          del 列表名[index1 : index2 : 步长 ]: 切片删除,有固定的格式,删除index1到index2的内容,后边可以选择切片的方向

    • pop():
    1 lst = ["盖伦", "大白梨", "提莫", "大白梨"]
    2 e = lst.pop()   # 返回删除的元素, 删除最后一个
    3 print(e)
    • remove():
    1 lst = ["盖伦", "大白梨", "提莫", "大白梨"]
    2 lst.remove("大白梨")
    3 print(lst)
    • clear():
    1 lst = ["盖伦", "大白梨", "提莫", "大白梨"]
    2 lst.clear()
    3 print(lst)
    • del():
    1 lst = ["盖伦", "大白梨", "提莫", "大白梨"]
    2 del lst[1:]
    3 print(lst)

        改:

          1.索引修改  通过列表索引来拿到对应的值进行修改操作

          2.切片修改   迭代修改

    • 索引修改:
    1 lst = ["太白", "五色", "银王", "日天"]
    2 lst[0] = "太黑"
    3 print(lst)
    4 lst[2] = "银角大王"
    5 print(lst)
    • 切片修改:
    1 lst[1:3] = "马化腾"    # 迭代修改
    2 print(lst)
    3 lst[1:3] = ["周杰伦", "他媳妇", "王力宏媳妇"]
    4 print(lst)

        查:

          列表是⼀一个可迭代对象, 所以可以进行for循环

    1 lst = ["舒克贝塔", "黑猫警长", "熊大熊二", "葫芦娃", "吴佩琪"]
    2 for el in lst:  #  element
    3     print(el)

        常用操作:

          count():  查询字符出现次数

          sort():     把列表元素进行排序

          len():      计算长度

    • count():
    1 lst = ["太白", "太黑", "五色", "银王", "日天", "太白"] 
    2 c = lst.count("太白")     # 查询太白出现的次数 
    3 print(c)
    • sort():
    1 lst = [1, 11, 22, 2] 
    2 lst.sort()          # 排序. 默认升序 
    3 print(lst) 
    4 lst.sort(reverse=True)  # 降序 
    5 print(lst)
    • len():
    1 l = len(lst) # 列表的长度
    
    2 print(l) 

       列表的嵌套:

           采用降维操作.一层一层的看就好.

     1 lst = [1, "太白", "wusir", ["马虎疼", ["可口可乐"], "王健林"]]
     2 
     3 # 找到wusir 
     4 print(lst[2])
     5 
     6 # 将wusir拿到. 然后首字母大写. 再扔回去
     7 lst[2] = lst[2].capitalize() 
     8 print(lst)
     9 
    10 # 把太白换成太黑 
    11 lst[1] = lst[1].replace("", "") 
    12 print(lst)
    • 元组的介绍:

      • 不可变的列表. 只读列表. 有索引和切片.
      • 不可变的是它内部子元素. 如果子元素是列表. 列表中的元素是可以变的.
    • 元组的基本操作:
     1 tu = (1, "太白", "李白", "太黑", "怎么黑")
     2 print(tu)
     3 
     4 print(tu[0])
     5 print(tu[2]) 
     6 print(tu[2:5])  # 切片之后还是元组
     7 
     8 
     9 
    10 # for循环遍历元组 
    11 for el in tu:
    12     print(el)

    >>>>>>小提示:元组也有count() , sort() , len() 等操作

    • set集合

      • 集合的特点: 不重复,无序的,用{ }表示
      • 注意: set集合中的元素必须是可hash的, 但是set本身是不可hash得. set是可变的.
      • 使用set的不重复特性来为列表去重
    1 lst = ['影流之主', '疾风剑豪', '诡术妖姬', '放逐之刃', '放逐之刃', '疾风剑豪', '卡牌大师']
    2 s = set(lst)
    3 lst = list(s)
    4 print(lst)

    >>>>>>>>>>> ['卡牌大师', '放逐之刃', '疾风剑豪', '诡术妖姬', '影流之主']

    • 集合的增删改查:

        增 :

          add() :   # 重复的内容不会被添加进去

          update() :  迭代添加

    • add() :

    1 s = {'疾风剑豪', '影流之主', '诡术妖姬', '卡特琳娜', '卡牌大师', '九尾妖狐', '光辉女郎'}
    2 s.add('刀锋之影')
    3 print(s)

    >>>>>>>>>> {'卡特琳娜', '疾风剑豪', '光辉女郎', '诡术妖姬', '影流之主', '刀锋之影', '卡牌大师', '九尾妖狐'}

    • update() : 

    1 s = {'疾风剑豪', '影流之主', '诡术妖姬', '卡特琳娜', '卡牌大师', '九尾妖狐', '光辉女郎'}
    2 s.update('刀锋之影')
    3 print(s)

    >>>>>>>>>>  {'刀', '卡牌大师', '卡特琳娜', '疾风剑豪', '锋', '之', '光辉女郎', '影流之主', '九尾妖狐', '诡术妖姬', '影'}

        删 :

          pop()  :   随机删除一个

          remove()  :  指定元素删除,如果指定的 元素不存在,则会报错

          clear() :   清空集合

     1 s = {"刘嘉玲", '关之琳', "王祖贤", "张曼玉", "李若彤"}
     2 item = s.pop()  # 随机弹出⼀一个.
     3 print(s)
     4 print(item)
     5 
     6 
     7 s.remove("关之琳")  # 直接删除元素 #
     8 s.remove("马虎疼")  # 不不存在这个元素. 删除会报错
     9 print(s)
    10 
    11 
    12 s.clear()    # 清空set集合.需要注意的是set集合如果是空的. 打印出来是set() 因为要和 dict区分的.
    13 print(s)    # set()

        改 :

          集合不能修改

        查 :

          for 循环迭代

    • 集合常用操作:

      • 交集:

    1 lst = {'林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易'}
    2 lst1 = {'周杰伦', '周星星', '周润发', '周树人', '林俊杰'}
    3 print(lst & lst1)
    # 4 print(lst.intersection(lst1))

    >>>>>>>>> {'林俊杰'}

      • 并集:

    1 lst = {'林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易'}
    2 lst1 = {'周杰伦', '周星星', '周润发', '周树人', '林俊杰'}
    3 print(lst | lst1)
    4 # print(lst.union(lst1))

    >>>>>>>>>> {'黄家驹', '周杰伦', '毛不易', '周润发', '陈奕迅', '周树人', '周星星', '林俊杰', '薛之谦'}

      • 差集:

    1 lst = {'林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易'}
    2 lst1 = {'周杰伦', '周星星', '周润发', '周树人', '林俊杰'}
    3 print(lst - lst1)
    4 # print(lst.difference(lst1))

    >>>>>>>>> {'毛不易', '陈奕迅', '薛之谦', '黄家驹'}

      • 反交集:

    1 lst = {'林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易'}
    2 lst1 = {'周杰伦', '周星星', '周润发', '周树人', '林俊杰'}
    3 print(lst ^ lst1)
    4 # print(lst.symmetric_difference(lst1))

    >>>>>>>>> {'周杰伦', '陈奕迅', '毛不易', '周润发', '黄家驹', '薛之谦', '周树人', '周星星'}

      • 子集:

    1 lst = {'林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易'}
    2 lst1 = {'周杰伦', '周星星', '周润发', '周树人', '林俊杰'}
    3 print(lst < lst1)
    4 # print(lst.issubset(lst1))

    >>>>>>>>> False

      • 超集:

    1 lst = {'林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易'}
    2 lst1 = {'周杰伦', '周星星', '周润发', '周树人', '林俊杰'}
    3 print(lst > lst1)
    4 # print(lst.issuperset(lst1))

    >>>>>>>>> False

     

    • 字典的介绍:

        1.用大括号{} 括起来. 内部使用key:value的形式来保存数据

        2.注意:字典的key必须是可哈希的. 不可变的, value 没有限制

        3.字典保存顺序不是按照我们输入的顺序保存的

      

    • 字典的操作方法:

        增:

          通过key添加,key不存在于原字典中才可添加,不然会替代原先的value。

    1 dic = {'林俊杰': '圣所', '薛之谦': '演员', '华晨宇': '悟空', '张杰': 100}
    2 dic['jc'] = "说散就散"
    3 print(dic) 

          setdefault()  :从字典末尾添加元素

    1 dic = {'林俊杰': '圣所', '薛之谦': '演员', '华晨宇': '悟空', '张杰': 100}
    2 dic.setdefault("cat", "study cat sing")
    3 dic.setdefault("cat", "la ji")    # 如果字典中已经包含了这个key,将不再保存
    4 print(dic)

        删:

          pop():删除字典中的元素,并返回删除的元素,可用变量接收

    1 dic = {1: 'Java', 2: 'c', 3: 'c++', 4: 'python'}
    2 ret = dic.pop(3)   # 通过key删除元素,返回这个元素的value值
    3 print(ret)
    4 print(dic)

          del  : 删除字典中的元素

    1 dic = {1: 'Java', 2: 'c', 3: 'c++', 4: 'python'}
    2 del dic[1]
    3 print(dic)

          items():随机删除

    1 dic = {1: 'Java', 2: 'c', 3: 'c++', 4: 'python'}
    2 ret = dic.popitem()   # 随机删除一个元素,返回一个元组
    3 print(dic)
    4 print(ret)

          clear():清空字典中所有元素

    dic = {1: 'Java', 2: 'c', 3: 'c++', 4: 'python'}
    dic.clear()
    print(dic)

        改:

          dict[存在的值] = 新值    相当于赋值

          dict.update(dict2)   把dict2的键值对(k-v)更新到dict中

    1 dic1 = {"李晨":"范冰冰", "邓超":"孙俪", "王祖蓝":"李亚男"}
    2 dic2 = {"李晨":"张馨予", "郑凯":"baby", "王宝强":"马蓉"}
    3 dic1.update(dic2)   #  把dic2中的内容更新到 dic1 , 如果存在了key. 替换. 如果不存在,添加
    4 print(dic1)
    5 print(dic2)

        查:

          get():查询字典中元素

    1 dic = {"及时雨":"宋江", "小李广":"花荣", "黑旋风":"李逵", "易大师":"剑圣"}
    2 print(dic.get("易大师", "余小C"))   # 如果key不存在. 返回None

         setdefault():字典中已经存在的key将不会再被添加,从而达到查询的效果

    1 dic = {"及时雨":"宋江", "易大师":"剑圣"}
    2 dic.setdefault("及时雨", "诺克萨斯")    # 可以帮我们查询
    3 print(dic)

         dict[key]  :  通过key查询字典中的元素

    1 dic = {"及时雨":"宋江", "小李广":"花荣", "黑旋风":"李逵", "易大师":"剑圣"}
    2 print(dic["及时雨"])
    • 字典的常用操作:

      • keys() 返回所有字典的key的集合(高仿列表)
    1 dic = {"及时雨":"宋江", "易大师":"剑圣", "维恩":"暗影猎手"}
    2 for key in dic.keys():  # 可以进行迭代循环
    3     print(key)
      • values() 返回所有的value的集合
    1 dic = {"及时雨":"宋江", "易大师":"剑圣", "维恩":"暗影猎手"}
    2 for value in dic.values():
    3     print(value)
      • items()  返回键值对. 元组
    1 dic = {"及时雨":"宋江", "易大师":"剑圣", "维恩":"暗影猎手"}
    2 for k, v in dic.items():
    3     print(k , v)
    • 解构,解包 

    1 a, b = (1, 2)
    2 print(a)
    3 print(b) 
    • 字典的嵌套: 

     1 dic = {
     2     "name":"汪峰",
     3     "age": 58,
     4     "wife":{
     5         "name":"国际章",
     6         "salary": 180000,
     7         "age": 37
     8     },
     9     "children":[
    10         {"name":"老大", "age": 18},
    11         {"name":"老二", "age": 118}
    12     ]
    13 }
    14 print(dic["children"][1]["age"])
    15 
    16 print(dic["wife"]['salary'])

    六、文件操作

    • 文件操作概念

           使用python来读写文件是非常简单的操作. 我们使用open()函数来打开一个文件, 获取到文 件句柄. 然后通过文件句柄就可以进行各种各样的操作了. 根据打开方式的不同能够执行的操作也会有相应的差异.

    • 文件操作方式: r ,  w  ,   a  ,  r+  , w+  , a+  , rb  , wb  , ab  , r+b  , w+b  , a+b   (默认使用r打开)

      • 文件操作 r (只读) 只能进行读取操作    read(n)     n只能为数字,表示读取到第几个位置,n为几,读取位置就截止到第几个字符
    1 f = open('info', 'r', encoding='utf-8')
    2 # s = f.read()    # 读取全部内容
    3 s = f.read(3)   # 默认从头开始读取,读取到第三个位置 , 如果再次读取,会从当前位置(光标处)开始读取
    4 f.close()
    5 print(s)
    View Code
      • 文件操作 w (写入) 只要用w写入内容,文件原本的内容就会全部删除
    1 f = open('info', 'w', encoding='utf-8')
    2 f.write('影流之主  劫')
    3 f.flush()
    4 f.close()
    View Code
      • 文件操作 a (追加) 可以在不该原文件内容的情况下添加新的内容
    1 f = open('info', 'a', encoding='utf-8')
    2 f.write('
    九尾妖狐 阿狸')
    3 f.flush()
    4 f.close()
      • 文件操作 r+ (读写) 打开文件可以进行读取和写入的操作 注意:如果先进行写入的操作,那么读取时只能读取到写入之后的内容
    1 f = open('info', 'r+', encoding='utf-8')
    2 f.write('
    熔岩巨兽 墨菲特')   # 如果先写再读,写入的内容会从开头开始覆盖,写入多少内容就会覆盖多少内容,然后光标会停在写入内容结束的位置
    3 s = f.read()     # 写入之后读取,会从光标处开始读取剩余的全部内容    所以正确的顺序应该是先读取再写入
    4 f.flush()
    5 f.close()
    6 print(s)
    View Code
    1 # 先读取再写入
    2 f = open('info', 'r+', encoding='utf-8')
    3 s = f.read()    # 先读取文件全部内容,光标会停留在最后
    4 print(s)
    5 f.write("
    熔岩巨兽 墨菲特")     # 然后在光标处添加内容
    6 f.flush()
    7 f.close()
    View Code
      • 文件操作 w+ (写读) 先将原文件的内容清空,然后写入内容,最后再读取内容,但是读取是读不到内容的(不常用)
    1 f = open('info', 'w+', encoding='utf-8')
    2 f.write('诺克萨斯之手 德莱厄斯')    # 清空文件,添加内容
    3 s = f.read()                     # 读取文件,但是读取的内容为空
    4 f.flush()
    5 f.close()
    6 print(s)
    View Code
      • 文件操作 rb (只读 非文本格式使用) 读取出来的数据是bytes类型, 在rb模式下. 不能选择encoding字符集.
    1 f = open('info', 'rb')
    2 s = f.read()   # 读取的内容直接就是字节
    3 print(s)
    4 f.close()
    View Code
      • 文件操作 readline() 逐行读取,将文件内容一行一行的显示出来,(会出现换行,可用 strip()来去除空格,换行符和制表符)
    1 f = open('info', 'r', encoding='utf-8')
    2 s = f.readline().strip()
    3 s1 = f.readline().strip()
    4 s2 = f.readline().strip()
    5 print(s)
    6 print(s1)
    7 print(s2)
    8 f.close()
      • 文件操作 readlines() 将每一个行形成一个元素,放到一个列表中,将所有内容都读取出来(不常用)
    1 f = open('info', 'r', encoding='utf-8')
    2 s = f.readlines()
    3 print(s)
    4 f.close()

        文件操作 seek()     seek(n)   n是光标的位置,n的单位是字节(byte) utf-8编码下,一个汉字等于3个字节

          seek()  使用方式:

            seek(0)  移动光标到开头位置

            seek(0,2)   移动光标到结尾位置

     1 f = open("小娃娃", mode="r+", encoding="utf-8") 
     2 f.seek(0)   # 光标移动到开头 
     3 content = f.read()  # 读取内容, 此时光标移动到结尾 
     4 print(content) 
     5 
     6 f.seek(0)   # 再次将光标移动到开头 
     7 f.seek(0, 2)    # 将光标移动到结尾 
     8 content2 = f.read()  # 读取内容. 什什么都没有 
     9 print(content2) 
    10 
    11 f.seek(0)   # 移动到开头 
    12 f.write("张国荣")  # 写⼊入信息. 此时光标在9  中⽂文3 * 3个 = 9 
    13 f.flush() 
    14 f.close()

        文件修改:  创建新文件. 把修改后的内容写入新文件. 删除老文件. 重命名新文件

     1 import os
     2 
     3 with open("吃的", mode="r", encoding="utf-8") as f1, 
     4         open("吃的_副本", mode="w", encoding="utf-8") as f2:
     5     for line in f1:
     6         s = line.replace("", "")
     7         f2.write(s)
     8 
     9 os.remove("吃的") # 删除文件
    10 os.rename("吃的_副本", "吃的")    # 重命名文件

    七、编码解码

    • 编码  

      • 最早的编码是ASCII码,美国人创建的.  8位   1字节  

      • gbk   国标码    16位    2字节  

      • unicode  万国码   32 位   4字节  

      • utf-8    : 英文   8位  1字节        欧洲  16位  2字节        中文   24位  3字节   

        计算机存储单位:    

          8 bit  ==>  1 byte    

          1024 byte  ==>  1 kb    

          1024 kb  ==>  1 mb    

          1024 mb ==>  1 gb    

          1024 gb  ==>  1 tb            

          1024 tb  ==>   1 pb

     

    • is 和 == 的区别

      • id()  通过id()我们可以查看到⼀一个变量表示的值在内存中的地址.

    1 a = "刀下生,刀下死"
    2 b = "刀下生,刀下死"
    3 print(id(a))
    4 print(id(b))
    View Code

    >>>>>>>>>1654269828768
    >>>>>>>>>1654269828768

    >>>>>>>>>两个字符串地址相同

    1 a = 123
    
    2 b = 123
    
    3 print(id(a),id(b)) 
    View Code

    >>>>>>>>>140708405633888 140708405633888

    >>>>>>>>>两个数字地址也相同

    1 a = ['yangxianqiang', 'pandeyong', 'hashiqi']
    2 b = ['yangxianqiang', 'pandeyong', 'hashiqi']
    3 print(id(a), id(b))
    View Code

    >>>>>>>>>2477147120200     2477147120264

    >>>>>>>>>两个列表地址不同

    1 a = ('abc', 2, 3, 4)
    2 b = ('abc', 2, 3, 4)
    3 print(id(a), id(b))
    View Code

    >>>>>>>>>2920342876392 2920342876392

    >>>>>>>>>两个元组地址也相同

    1 a = {1: 'xiazi', 2: 'yasuo', 3: 'feizi'}
    2 b = {1: 'xiazi', 2: 'yasuo', 3: 'feizi'}
    3 print(id(a), id(b))

    >>>>>>>>>>2244009621904 2244009621976

    >>>>>>>>>>两个字典地址也不相同

    • 》》》》》》结论(仅供参考)

        小数据池(常量池): 把我们使用过的值存储在⼩小数据池中.供其他的变量使用.

        小数据池给数字和字符串使用, 其他数据类型不存在.

        对于数字: -5~256是会被加到小数据池中的. 每次使用都是同一个对象.

        对于字符串:

          1. 如果是纯文字信息和下划线. 那么这个对象会被添加到小数据池

          2. 如果是带有特殊字符的. 那么不会被添加到小数据池. 每次都是新的

          3. 如果是单一字母*n的情况. 'a'*20, 在20个单位内是可以的. 超过20个单位就不会添加 到小数据池中

    注意(一般情况下): 在py文件中. 如果你只是单纯的定义一个字符串. 那么一般情况下都是会 被添加到小数据池中的. 我们可以这样认为: 在使用字符串的时候, python会帮我们把字符串串进行缓存, 在下次使用的时候直接指向这个字符串即可. 可以节省很多内存.

    • is :  is比较的就是id()计算出来的结果. 由于id是帮我 们查看某数据(对象) 的内存地址. 那么is比较的就是数据(对象)的内存地址.
    • == : 双等表示的是判断是否相等, 注意. 这个双等比较的是具体的值.而不是内存地址
    1 s1 = "哈哈"
    2 s2 = "哈哈"
    3 print(s1 == s2)  # True print(s1 is s2)  
    4 #  True 原因是有小数据池的存在 导致两个变量指向的是同一个对象
    5 l1 = [1, 2, 3]
    6 l2 = [1, 2, 3]
    7 print(l1 == l2)  # True, 值是⼀一样的
    8 print(l1 is l2)  # False, 值是假的
    View Code

    >>>>>>>>>>True

    >>>>>>>>>>True

    >>>>>>>>>>False

    总结:    

      is 比较的是地址   

      == 比较的是值

    • 编码的补充

      • 编码回顾:

          ASCII  :  英文   8bit    1byte

          GBK :   中文    16bit   2byte

          Unicode :  万国码  32bit  4byte

          utf-8 : 英文  8bit   1byte

             欧洲   16bit  2byte

             中文   24bit  3byte

      • bytes的表现形式:

          1) : 英文   b'alex'  英文的表现形式和字符串没什么两样

          2) : 中文   b'xe4xb8xad' 这是一个汉字的UTF-8的bytes表现形式

      • 编码 :  字符串在传输时转化成bytes=> encode(字符集)来完成

    1 s = "alex"
    2 print(s.encode("utf-8"))    # 将字符串编码成UTF-8
    3 print(s.encode("GBK"))  # 将字符串编码成GBK

    >>>>>>>>>>b'alex'

    >>>>>>>>>>b'alex'

    1 s = ""
    2 print(s.encode("UTF-8"))    # 中文编码成UTF-8
    3 print(s.encode("GBK"))  # 中文编码成GBK

    >>>>>>>>>>b'xe4xb8xad'

    >>>>>>>>>>b'xd6xd0'

      • 解码 :  我们可以使用decode()来进行解码操作. 把bytes类型的数据还原回我们熟悉的字符串

    1 s = "我叫李李嘉诚"
    2 print(s.encode("utf-8"))    # b'xe6x88x91xe5x8fxabxe6x9dx8exe5x98x89xe8xafx9a'
    3 print(b'xe6x88x91xe5x8fxabxe6x9dx8exe5x98x89xe8xafx9a'.decode("utf-8"))  # 解码

    编码和解码的时候都需要制定编码格式

    1 s = "我是⽂字"
    2 bs = s.encode("GBK")    # 我们这样可以获取到GBK的⽂文字
    3 #  把GBK转换成UTF-8
    4 #  首先要把GBK转换成unicode. 也就是需要解码
    5 s = bs.decode("GBK")  # 解码
    6 #  然后需要进行重新编码成UTF-8
    7 bss = s.encode("UTF-8") # 重新编码 
    8 print(bss)

    八、深浅拷贝

    • 深浅拷贝

        赋值操作:

    1 lst = ['林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易']
    2 lst1 = lst
    3 lst1.append('周杰伦')
    4 print(lst)
    5 print(lst1)

    >>>>>>>>>>> ['林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易', '周杰伦']
    >>>>>>>>>>> ['林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易', '周杰伦']

      对于list, set, dict来说, 直接赋值. 其实是把内存地址交给变量. 并不是复制一份内容. 所以. lst的内存指向和lst1是一样的. lst1改变了, lst也发生了改变

    • 浅拷贝:

    1 lst = ['yasuo', 'xiazi', 'yingliu']
    2 lst1 = lst.copy()
    3 # lst1 = lst[:]     # 切片也是复制
    4 lst.append('shitouren')
    5 lst1.append('jiqiren')
    6 print(lst)
    7 print(lst1)

    >>>>>>>>>>>> ['yasuo', 'xiazi', 'yingliu', 'shitouren']
    >>>>>>>>>>>> ['yasuo', 'xiazi', 'yingliu', 'jiqiren']

      两个lst完全不一样. 内存地址和内容也不一样. 发现实现了内存的拷贝,浅拷贝只能实现第一层的拷贝

    • 深拷贝:

    1 import copy
    2 
    3 lst = ['林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易', ['田馥甄', 'jc', '于文文']]
    4 lst1 = copy.deepcopy(lst)
    5 lst[5].append('杨钰莹')
    6 print(lst)
    7 print(lst1)

    >>>>>>>>>>>>>> ['林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易', ['田馥甄', 'jc', '于文文', '杨钰莹']]
    >>>>>>>>>>>>>> ['林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易', ['田馥甄', 'jc', '于文文']]

      深度拷贝. 把元素内部的元素完全进行拷贝复制. 不会产生一个改变另一个跟着改变的问题

  • 相关阅读:
    【eclipse】Server Tomcat v9.0 Server at localhost failed to start.
    【eclipse】运行maven项目clean tomcat7:run报错
    window下安装redis报错: creating server tcp listening socket 127.0.0.1:6379: bind No error
    【eclipse】svn在线安装
    【eclipse】点Clean后没反应
    谷歌浏览器&360浏览器安装——有道云笔记插件
    阿里云企业邮箱设置
    PyTorch 高级实战教程:基于 BI-LSTM CRF 实现命名实体识别和中文分词
    最全Pycharm教程(43)——Pycharm扩展功能之UML类图使用 代码结构
    精选Pycharm里6大神器插件
  • 原文地址:https://www.cnblogs.com/child-king/p/9255780.html
Copyright © 2011-2022 走看看