您的位置: 首页  >  IT文章  >  python基础 三、运算符  四、if条件判断、while循环、for循环 range 五、字符串、列表、元组、字典、集合操作   六、文件操作 七、编码解码   八、深浅拷贝

python基础 三、运算符  四、if条件判断、while循环、for循环 range 五、字符串、列表、元组、字典、集合操作   六、文件操作 七、编码解码   八、深浅拷贝

分类: IT文章 • 2023-11-03 10:54:18

一、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")
else：
    print("对不起，你猜错了")

>>>>>>>>>>>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', '于文文']]

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

相关推荐