第一模块（开发基础）-第二章数据类型和文件操作_a={1,2,3,4,2,'alex',3,'rain','alex'}-CSDN博客

本文链接：https://blog.csdn.net/qq_36993243/article/details/108719516

本文详细介绍了Python中的数据类型，包括变量创建、身份运算、None、列表、元组、字符串和字典的操作。内容涵盖列表的增删改查、元组的不可变性、字符串的格式化和操作以及字典的增删改查。此外，还讲解了二进制、字符编码、文件操作的基本概念和方法。

摘要由CSDN通过智能技术生成

系列文章目录

文章目录

系列文章目录
前言
一、变量的创建过程
二、身份运算和none
三、细讲数据类型-列表
四、细讲数据类型-元组
五、细讲数据类型-字符串
六、细讲数据类型-字典
七、细讲数据类型-集合
八、秒懂二进制
九、字符编码之文字是如何显示的
十、秒懂十六进制
十一、hash是个什么东西
十二、用python操作文件
总结

前言

数据类型&文件操作

一、变量的创建过程

name = “Alex”
python解释器有自动垃圾回收机制，自动隔一段时间，把没有跟变量名关联的内存数据回收

二、身份运算和none

身份运算
代码如下：

>>> type(age) is int
True
>>> type(age) is not int
False

None 什么也没有
空 empty

代码如下：

name = None
age = None
weight = None
height = None
if name is None:
	print("你还没起名字呢")

三元运算
代码如下：

a = 10
b = 5
if a >15:
	c = a
else:
	c = b
d = a if a > 15 else b

d = 值1 if 条件A else 值2

如果条件A成立，就取左边的值1，否则取值2

三、细讲数据类型-列表

name = “alex,jack”
names = [“alex”,“jack”]
names[1] = “Mack”

增加

1.追加，数据会追加到尾部

>>> names
['alex', 'jack']
>>> names.append("rain")
>>> names.append("eva")
>>> 
>>> names
['alex', 'jack', 'rain', 'eva']

2.插入，可插入任何位置

>>> names.insert(2,"黑姑娘")
>>> names
['alex', 'jack', '黑姑娘', 'rain', 'eva']
>>>

3.合并,可以把另外一列表的值合并进来

>>> n2 = ["狗蛋","绿毛","鸡头"]
>>> names
['alex', 'jack', '黑姑娘', 'rain', 'eva']
>>> names.extend(n2)
>>> names
['alex', 'jack', '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛', '鸡头']
>>>

列表嵌套

>>> names.insert(2,[1,2,3])
>>> names 
['alex', 'jack', [1, 2, 3], '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛', '鸡头']
>>> names[2][1]
2

删
1.del 直接删

>>> names
['alex', 'jack', [1, 2, 3], '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛', '鸡头']
>>> del names[2]
>>> names
['alex', 'jack', '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛', '鸡头']

2.pop 删

>>> names
['alex', 'jack', '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛', '鸡头']
>>> names.pop() #默认删除最后一个元素并返回被删除的值
'鸡头'
>>> names
['alex', 'jack', '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛']
>>> help(names.pop)
>>> names.pop(1)  #删除指定元素
'jack'

3.clear 清空

>>> n2
['狗蛋', '绿毛', '鸡头']
>>> n2.clear()
>>> n2
[]

4.remove 删除指定元素

#如有重复值，从左到右删到第一个值
>>> names.remove(1)
>>> names
[2, 3]
#删掉不存在的值，会报错

改
赋值

>>> names
['alex', '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛']
>>> names[0] = "金角大王"
>>> names[-1] = "银角大王"
>>> names
['金角大王', '黑姑娘', 'rain', 'eva', '狗蛋', '银角大王']

查
查询

>>> names
['金角大王', '黑姑娘', 'rain', 'eva', '狗蛋', '银角大王', 'eva']
>>> 
>>> names.index("eva") #返回从左开始匹配到的第一个eva的索引
3
#查不存在的值会报错，ValueError: 1 is not in list
>>> names.count("eva") #返回eva的个数
2
>>> 2 in names
True

切片

names[start:end]

>>> names
['金角大王', '黑姑娘', 'rain', 'eva', '狗蛋', '银角大王', 'eva']
>>> names[1:4]  #不包含下标4的元素
['黑姑娘', 'rain', 'eva']
#切片的特性是顾头不顾尾，即start的元素会被包含，end-1是实际取出来的值

取前几个值

>>> names
['金角大王', '黑姑娘', 'rain', 'eva', '狗蛋', '银角大王', 'eva']
>>> names[0:3]
['金角大王', '黑姑娘', 'rain']
>>> names[:3]  #跟上面一样的效果
['金角大王', '黑姑娘', 'rain']

倒着切

>>> names[-5:-1]
['rain', 'eva', '狗蛋', '银角大王']
>>> names[-5:]
['rain', 'eva', '狗蛋', '银角大王', 'eva']

步长 = 步子的长度
names[-5:-1]

步长-1代表真正的从右往左走

>>> a
['金角大王', '黑姑娘', 'rain', 'eva', '狗蛋', '银角大王', 'eva']
a[-1:-5:-1]
>>>['eva', '银角大王', '狗蛋', 'eva']

names[start: end: step]

>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[0:7:2]  #设置步长为2
[0, 2, 4, 6]

>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> 
>>> a[::3] #按步长3打印列表，第1个:是省略掉的start:end
[0, 3, 6, 9]

列表反转

>>> a[::-1] #通过把步长设置成负值，可达到列表返转的效果
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0] 
>>> a[::-2]
[9, 7, 5, 3, 1]

排序

1.数字排序

>>> a = [83,4,2,4,6,19,33,21]
>>> a.sort()
>>> a
[2, 4, 4, 6, 19, 21, 33, 83]

2.字符串排序

>>> names=['金角大王', 'rain', '@', '黑姑娘', '狗蛋', "4","#",'银角大王', 'eva']
>>> names.sort()
>>> names
['#', '4', '@', 'eva', 'rain', '狗蛋', '金角大王', '银角大王', '黑姑娘']

反转

反转列表

>>> names
['#', '4', '@', 'eva', 'rain', '狗蛋', '金角大王', '银角大王', '黑姑娘']
>>> names.reverse()
>>> names
['黑姑娘', '银角大王', '金角大王', '狗蛋', 'rain', 'eva', '@', '4', '#']

循环

循环列表

>>> for i in names:  
...     print(i)
... 
黑姑娘
银角大王
金角大王
狗蛋
rain
eva
@
4
#

四、细讲数据类型-元组

不可变 = 只读列表

创建

ages = (11, 22, 33, 44, 55)
#或
ages = tuple((11, 22, 33, 44, 55))

常用操作

#索引
>>> ages = (11, 22, 33, 44, 55)
>>> ages[0]
11
>>> ages[3]
44
>>> ages[-1]
55
#切片:同list　　
#循环
>>> for age in ages:
    print(age)
11
22
33
44
55
#长度
>>> len(ages)
5
#包含
>>> 11 in ages
True
>>> 66 in ages
False
>>> 11 not in ages
False

元组本身不可修改，如果包含可修改的数据类型，那被包含的数据可以修改：

>>> data 
(99, 88, 77, ['Alex', 'Jack'], 33)
>>> data[3][0] = '金角大王'
>>> data
(99, 88, 77, ['金角大王', 'Jack'], 33)

五、细讲数据类型-字符串

1.首字母大写

>>> a = "jack li"
>>> a.capitalize()
'Jack li'

2.把字符串全变大写

>>> n2.upper()
'ALEX,JACK,RAINHAHAHA|DD'

3.把字符串全变小写

>>> b = "BOLD"
>>> b.casefold()
'bold'

4.把字符串全变小写

>>> b = "AlexJack"
>>> b.lower()
'alexjack'

casefold()与lower()的区别：casefold函数可识别更多的对象将其输出为小写，而lower函数只能完成ASCII码中A-Z之间的大写到小写的转换，当遇到其他外语语种时，大写向小写转换lower函数就无能为力

5.填充字符串长度

>>> a
'jack li'
>>> a.center(80,"*")
'************************************jack li*************************************'
>>>

6.统计字符

>>> s = "welcome to apeland"
>>> s.count('e')
3
>>> s.count('e',3)
2
>>> s.count('e',10,-1)
1

7.判断是否以某个字符结尾

>> > s = "welcome to apeland"
>> > s.endswith("land") 
True
>>> s.endswith("p")
False

8.判断是否以某个字符开始

>>> s.startswith("w")
True
>>> s.startswith("o")
False

9.寻找元素，返回下标

>>> s.find("t")
8
# 从下标11开始，查找在字符串里第一个出现的子串：返回结果
>>> s.find("e",11)
13
#找不到，返回-1
>>> s.find("q")
-1

10.format填充

s = "Welcome {0} to Apeland,you are No.{1} user."
s.format("Eva",4)
'Welcome Eva to Apeland,you are No.4 user.'

s = "Welcome {0} to Apeland,you are No.{1} user,{0}."
s.format("eva",3)
'Welcome eva to Apeland,you are No.3 user,eva.'

s1 = "Welcome {name} to Apeland,you are No.{user_num} user."
s1.format(name = "alex",user_num = 1)
'Welcome alex to Apeland,you are No.1 user.'

11.返回索引下标，str.index(str, beg=0, end=len(string))

#如果str不在 string中会报一个异常
>>> s1.index("1")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

>>> s1.index('l')
2
>>> s1.index('l',10)
21

12.判断字符串是否全是小写

str = "THIS is string example....wow!!!"; 
print str.islower();
False

str = "this is string example....wow!!!";
print str.islower();
True

13.判断字符串是否全是大写

>>> a = 'plane'
>>> a.isupper()
False

>>> b = 'READ'
>>> b.isupper()
True

14.大小写交换

>>> a = 'plane'

>>> a.swapcase()
'PLANE'

15.判断字符串是否是空格

>>> ''.isspace()
False

>>> ' '.isspace()
True

16.去掉两边空格

>>> a = "  alex  "
>>> a.strip()
'alex'

17.去掉左边空格

>>> a.lstrip()
'alex  '

18.去掉右边空格

>>> a.rstrip()
'  alex'

19.字符串拼接
将序列中的元素以指定的字符连接生成一个新的字符串

>>> n = ["alex","jack","rain"]

>>> "".join(n)
'alexjackrain'

>>> " ".join(n)
'alex jack rain'

>>> ",".join(n)
'alex,jack,rain'

>>> "-".join(n)
'alex-jack-rain'

20.从左数不够长的填充

>>> a
'plane'

>>> a.ljust(50,'*')
'plane*********************************************'

21.从右数不够长的填充

>>> a.rjust(50,'*')
'*********************************************plane'

22.定义长度，不够用0补

>>> a.zfill(10)
'00000plane'

23.替换

>>> a = "My score is 580,not 580 very good"

>>> a.replace("580","630")
'My score is 630,not 630 very good'

>>> a.replace("580","630",1)
'My score is 630,not 580 very good'

24.字符串分割
通过指定分隔符对字符串进行切片，返回分割后的字符串列表

n2 = ",".join(n)
>>> n2
'alex,jack,rain'

>>> n2.split()
['alex,jack,rain']

>>> n2.split(",")
['alex', 'jack', 'rain']

>>> n2.split(",",1)
['alex', 'jack,rain']

>>> n2 += "hahaha|dd"
>>> n2.split("|")
['alex,jack,rainhahaha', 'dd']

>>> n2.split(",",1)
['alex', 'jack,rainhahaha|dd']

25.从右开始分

>>> n2.rsplit(",")
['alex', 'jack', 'rain']

>>> n2.rsplit(",",1)
['alex,jack', 'rain']

查
find,index,count
改
replace
upper.lower,casefold,swapcase,strip,split
格式化
format,ljust,rjust,join
判断
isdigit,startswith,endswith,isupper,islower,isspace

六、细讲数据类型-字典

创建

person = {"name": "alex", 'age': 20}

{}.fromkeys(seq,100) #不指定100默认为None
#注意
>>> dic={}.fromkeys(['k1','k2'],[])
>>> dic
{'k1': [], 'k2': []}
>>> dic['k1'].append(1)
>>> dic
{'k1': [1], 'k2': [1]}

新增

>>> d
{'name': 'alex', 'age': 20}
#直接新增，如字典中有这个索引，直接修改
>>> d["job"] = "teacher"
>>> d
{'name': 'alex', 'age': 20, 'job': 'teacher'}
>>>
#字典中没有这个索引的时候新增，返回新增的值
>>> d.setdefault("salary",[1,2,3])
[1, 2, 3]
>>> d
{'name': 'alex', 'age': 20, 'job': 'teacher', 'salary': [1, 2, 3]}
#字典中有这个索引的时候不修改，返回原来的值
>>> d.setdefault("salary",[1,78,6])
[1, 2, 3]
>>> d
{'name': 'alex', 'age': 20, 'job': 'teacher', 'salary': [1, 2, 3]}
>>>

删除

# 通用删除
>>> d
{'name': 'alex', 'age': 20, 'job': 'teacher', 'salary': [1, 2, 3]}
>>> del d['name']
>>> d
{'age': 20, 'job': 'teacher', 'salary': [1, 2, 3]}

#删除指定索引
>>> d
{'age': 20, 'job': 'teacher', 'salary': [1, 2, 3]}
>>> d.pop("salary")
[1, 2, 3]
>>> d
{'age': 20, 'job': 'teacher'}

#随机删除
 >>> d
{'age': 20, 'job': 'teacher'}
>>> d.popitem()
('job', 'teacher')
>>> d
{'age': 20}   

#清空      
>>> d
{'age': 20}
>>> d.clear()
>>> d
{}

修改

#如果key在字典中存在，'new_value'将会替代原来的value值
dic['key'] = 'new_value'

#dic.update(dic2)将字典dic2的键值对添加到字典dic中
d
{'name': 'alex', 'age': 2}
>>> d2
{'age': 20, 'job': 'teacher', 'salary': [1, 2, 3]}
>>> d.update(d2)
>>> d
{'name': 'alex', 'age': 20, 'job': 'teacher', 'salary': [1, 2, 3]}

查

#in
>>> "age2" in d
False
>>> "age" in d
True

#get
>>> d.get("age")
20
>>> d.get("age2")
none
#不存在，返回-1
>>> d.get("age2",-1)
-1

#返回一个包含字典所有KEY的列表
>>> d.keys()
dict_keys(['name', 'age', 'job', 'salary'])
#返回一个包含字典所有value的列表
>>> d.values()
dict_values(['alex', 20, 'teacher', [1, 2, 3]])
#返回一个包含所有（键，值）元组的列表
>>> d.items()
dict_items([('name', 'alex'), ('age', 20), ('job', 'teacher'), ('salary', [1, 2, 3])])

循环

#键
>>> for i in d:
...   print(i)
...
name
age
job
salary

#值
>>> for i in d:
...   print(d[i])
...
alex
20
teacher
[1, 2, 3]
>>>     

#键值
>>> for i in d:
...   print(i,d[i])
...
name alex
age 20
job teacher
salary [1, 2, 3]

求长度

>>> len(d)
4

七、细讲数据类型-集合

py [1,2,3,4]
web [2,5,6,7,8]
去重

>>> a = {1,2,3,4,2,'alex',3,'rain','alex'}
>>> a
{1, 2, 3, 4, 'rain', 'alex'}
>>> a = [1,2,3,4,2,'alex',3,'rain','alex']
>>> a
[1, 2, 3, 4, 2, 'alex', 3, 'rain', 'alex']
>>> set(a)
{1, 2, 3, 4, 'rain', 'alex'}
>>> a = set(a)
>>> type(a)
<class 'set'>

增

#存在的值不能加进去
>>> a.add(3)
>>> a
{1, 2, 3, 4, 'rain', 'alex'}
#只能存不存在的值
>>> a.add(5)
>>> a
{1, 2, 3, 4, 'rain', 5, 'alex'}
#不能加可变的值
>>> a.add([0,5,6])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

删

#删除一个存在的值
>>> a.discard(5)
>>> a
{1, 2, 3, 4, 'rain', 'alex'}
#如果这个值不存在，do nothing.
>>> a.discard(5)
>>> a
{1, 2, 3, 4, 'rain', 'alex'}

#remove删
>>> a.remove(2)
>>> a
{3, 4, 'rain', 'alex'}
#如果这个值不存在，报错
>>> a.remove(5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 5

#随机删
>>> a.pop()
1

查

>>> 'rain' in a
True

循环

>>> for i in a:
...   print(i)
...
3
4
rain
alex

关系运算

s_1024 = {"佩奇","老男孩","海峰","马JJ","老村长","黑姑娘","Alex"}
s_pornhub = {"Alex","Egon","Rain","马JJ","Nick","Jack"}

# 交集, elements in both set
print(s_1024 & s_pornhub)  

# 并集 or 合集，合并去重
print(s_1024 | s_pornhub)  

# 差集 , only in 1024
print(s_1024 - s_pornhub)  

# 差集,  only in pornhub
print(s_pornhub - s_1024)  

# 对称差集, 把脚踩2只船的人T出去
print(s_1024 ^ s_pornhub)

两个集合之间一般有三种关系，相交、包含、不相交。在Python中分别用下面的方法判断：

# 判断2个集合是不是不相交，返回True or False
>>> s_1024.isdisjoint(s_pornhub)
False

# 判断s_1024是不是s_pornhub的子集，返回True or False
>>>print(s_1024.issubset(s_pornhub))       
False
# 判断s_1024是不是s_pornhub的父集，返回True or False
print(s_1024.issuperset(s_pornhub))

八、秒懂二进制

A B
1
100000

九、字符编码之文字是如何显示的

128 64 32 16 8 4 2 1
二进制 ——》十进制
A 95
l 108
e
x
设定为每8个二进制位代表一个字符

bit 位，计算机中最小的表示单位
8bit = 1bytes 字节，最小的存储单位，1bytes缩写为1B
1KB=1024B
1MB=1024KB
1GB=1024MB
1TB=1024GB
1PB=1024TB
1EB=1024PB
1ZB=1024EB
1YB=1024ZB
1BB=1024YB

如果两个高位字节同时出现，就认为是个中文字符，去GBK编码表里找值，否则就使用ASCII码方式实现编码

中国人使用GBK的同时，日本人，shift_JIS,KS…,TH…
日本游戏 ——》中国，电脑上没有编码集——》导致乱码

要想不乱——》装语言包 shift_JIS——》能在中国电脑上正常显示日文

很麻烦，文化交流障碍

联合国万国码

支持全球所有的语言 Unicode 2-4字节已经收录136690个字符，并还在一直不断扩张中…
还可以与全球各个语言进行转换，unicode->GBK->shift_JIS->Big5
为什么要跟各个语言互相转
1990
1980
1.很多软件基于gb2312开发，转向unicode等于推倒重来
2.unicode = 英语，gb2312 = 汉语，没有强烈的需求要全转成unicode
全球计算机厂商出场都支持unicode
大多数软件的程序都支持unicode

unicode带来了新问题，在内存里没问题，传输或存到硬盘上，空间大了一倍，浪费+效率低

针对unicode的传输+存储，做了一个新编码，utf-8

UTF-8：使用1、2、3、4个字节表示所有字符；优先使用1个字符、无法满足则使增加一个字节，最多4个字节。英文占1个字节、欧洲语系占2个、东亚占3个，其它及特殊字符占4个
UTF-16：使用2、4个字节表示所有字符；优先使用2个字节，否则使用4个字节表示
UTF-32：使用4个字节表示所有字符

文字在内存里->unicode，到硬盘里传输，->utf-8

py2 = ascii
py3 = unicode

py2 vs py3

十、秒懂十六进制

十一、hash是个什么东西

密码 md5加密算法
基于hash，保证同样的输入得出的结果值一直一致
abc123 -193939013973114579
文件完整性校验
20gb ------>ssjjhhbfddkkk
数字签名
A------>B
C
A 天王盖地虎私钥 ——加密，把情报进行hash生成一段hash值（摘要信息），把摘要进行加密，把原文+加了密的摘要信息，一同发给B
B 宝塔镇河妖公钥——解密，把摘要解密，得到hash值。B对原文进行hash，也得到一个hash值，拿这个值，跟A发过来的值比较，如果一致，代表情报发送者是A本人

基于hash的类型
dict 的key都是经过hash运算

key唯一
key不可变
查询速度快且不受dict大小影响

kd = [-10, 53, 67, 81, 99, 123]
二分法
d[“赵六”]

set
200 ——> 内存里存的位置

十二、用python操作文件

1.找到文件，打开
2.读，修改
3.保存&关闭

1.f = open(filename)
2.f.read(100) f.read()读所有,f.write(you data)
3.f.close()

文件打开模式，只能以一种模式操作文件
r read
w write 创建模式
a append

创建

f = open(file = '','w')
f.write("Alex  CEO  600\n")
f.write("黑姑娘  行政  5000\n")
f.close()

读

f = open(file = '','r')
print(f.readline())  # 读一行
print('------分隔符-------')
data = f.read()  # 读所有，剩下的所有
print(data)
f.close()

追加

f = open(file = '','a')
f.write("黑姑娘 北京  168  48\n")  # 会追加到文件尾部
f.close()

循环文件

f = open(file='D:\staff.txt',mode='r')
for line in f:
    # print(line.strip())
    line = line.split()
    height = int(line[2])
    weight = int(line[3])
    if height > 170 and weight < 50:
        print(line)
f.close()

for i in range(100):
    print(i)

其他功能

#返回文件打开的模式
>>> f.mode
'a'

#返回文件名
>>> f.name
'D:\\staff.txt'
        
#把文件从内存buffer里强制刷新到硬盘
f.flush()

#判断是否可读
>>> f.readable()
False       

#只读一行，遇到\r or \n为止
f.readline()     

#把操作文件的光标移到指定位置
>>> f.seek(3)
3     

#判断文件是否可进行seek操作
>>> f.seekable()
True

#返回当前文件操作光标位置 
>>> f.tell()
3

#按指定长度截断文件,指定长度的话，就从文件开头开始截断指定长度，不指定长度的话，就从当前位置到文件尾部的内容全去掉
f.truncate(100)

#判断文件是否可写
f.writable()
False