Python基础——上节补充及数据类型

1.变量的创建过程

当我们创建一个变量name='oldboy'时，实际上是这样一个过程。

程序先开辟了一个内存空间，把变量的内容放进去，再让变量name指向'oldboy’所在的内存地址。

我们可以通过id(name)来查看变量所指向的内存地址，即'oldboy'所在的内存地址。

当变量修改时，name='alex',变量就会再开辟一块内存空间，只想‘alex'所在的内存地址，同时断开与'oldboy'之间的连接。

这时id(name)会得到与之前不同的内存地址。比如name指向'oldboy'时的内存地址为4317182301，那么name指向‘alex'的内存地址就可能是4317182360。

当一个变量的值改变时，这个变量会指向新得内存地址，原来数据所占据的内存空间会被释放掉，这就是变量的垃圾回收机制。

如果name1='oldboy' ,name2='oldboy'，那么name1和name2指向同一个内存地址。

但是，当name1='alex'时，程序会开辟一个新的内存地址，name1指向'alex'所在的内存地址，同时也断开了与'oldboy'的连接。

2.身份运算

Python中有很多数据类型，查看数据的数据类型可用type()方法。

name = 'alex'
print(type(name))

上面两行代码的运行结果就是<class 'str'> ,class是类的意思，后面会学习，可以看到name变量是str类型。

判断一个数据的数据类型是不是str 或者 int ,可用is , is not 方法

is就是判断一个数据是不是这样一个身份，比如

name = 'alex'
print(type(name) is str)

两行代码判断name是不是str类型，结果为True。

name = 'alex'
print( name is str)

这样运行的结果为False，因为name是一个实实在在的字符串，而并不是字符串类型。

is not 就是判断这个数据是否不是这样的什么，相对应。

3.空值None

None就是什么都没有的意思，通常用作初始化一个变量。即需要提前声明，但不知道应该设置一个怎样的值是，可以将其设置为None。

可用is运算符判断一个变量是否为None。

4.三元运算

#普通青年写法
name = 'alex'
sex = None
if name == 'alex':
    sex = 'male'
else:
    sex = 'female'

#装逼青年写法
sex = 'male' if name == 'alex' else "female"

三元运算就是将if..else语句缩成一行 ，判断成立，值等于左边；判断不成立，值为右边。

5.细讲数据类型

列表

(1) 定义：[ ]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素。

(2) 特点：可以存放多个值；可以存放各种数据类型；索引从0开始，每一个值按照索引排列；通过索引可以修改对应位置的元素的值。

(3) 列表的增删改查 ：列表的内置方法会改变列表本身。

增

#append()方法，在列表最后追加一个元素
names = ['alex', 'eric'] #创建一个列表，里面存放两个元素。
names.append('peiqi')
print(names)  # names = ['alex', 'eric', 'peiqi']

#insert()方法，插入一个元素，可插入任何位置。
names.insert(2,'mjj')
print(names)  # names = ['alex', 'eric', 'mjj', 'peiqi']

#extend(),可以将两个列表合并起来
age = [23,24,25]
names.extend(age)
print(names)  #names=['alex', 'eric', 'mjj', 'peiqi', 23, 24, 25]

#列表内部也可以嵌套列表
names.insert(4,[1,2,3])
print(names)  # names=['alex', 'eric', 'mjj', 'peiqi', [1,2,3],23, 24, 25]

删

#del 直接删 ，可以删除元素，也可以直接删除整个列表
names = ['alex', 'eric', 'mjj', 'peiqi', [1,2,3], 23, 24, 25]
del names[1]  #删除第二个元素
print(namas)  # ['alex', 'mjj', 'peiqi', [1,2,3], 23, 24, 25]
# del names  删除整个列表

#remove()方法,用来删除指定的内容
names.remove('peiqi')
print(names)  # names = ['alex', 'mjj', [1,2,3], 23, 24, 25]

#pop() 默认删除最后一个元素并返回被删除的值,也可以删除指定索引的值
a = names.pop()
print(names)  # names = ['alex', 'mjj', [1,2,3], 23, 24]
print(a) # a为25
names.pop(1)  # names = ['alex', [1,2,3], 23, 24]

#clear() 清空列表
names.clear()
print(names)  # names = []

改

#通过索引来查找元素和修改元素，可以用通过负数来倒序查找元素，如索引值为-1查找的就是最后一个元素。
names = ['alex', 'eric', 'mjj', 'peiqi']
a = names[0]
b = names[1]
c = names[-1]
print(a,b,c)  # 运行结果：'alex' 'eric','peiqi'

names[1] = 'yun'
print(names)  #  names = ['alex', 'yuan', 'mjj', 'peiqi']

查

# index() 方法,返回从左开始匹配到的第一个元素的索引值,
names = ['alex', 'eric', 'mjj', 'peiqi'，'alex']
a = names.index('mjj')
b = names.index('alex')
print(a)  #结果为 2
print(b)  #结果为0

#count()方法，返回元素的个数
c = names.count('alex')
print(c)  # 结果为2

(4)切片

切片就像切面包，可以去除多个元素的值

形式：names[start:end]

#切片特点：顾头不顾尾,names[start,end] 实际取出的是索引从start到end-1对应的元素.
names=['alex', 'eric', 'mjj', 'peiqi', [1,2,3],23, 24, 25]
a = names[1:4]
print(a)  # a 为 ['eric', 'mjj', 'peiqi'] 

#倒着切，列表也可以通过负的索引值切
b=names[-5:-1]
print(b)  # b 为 [ 'peiqi', [1,2,3],23, 24] 不包含最后一个元素

b=names[-1:-5]只取出了四个元素，因为切片顾头不顾尾的特性。如果想取出最后五个元素可以通过这种方法

b = names[-5:]
print(b)  # b为['peiqi', [1,2,3], 23, 24, 25]

names[start:]省略end，会从start开始一直取到最后。

names[:end]省略start，会从第一个元素取到end-1.

names[:]即可取得所有元素。

列表的切片不管起始和终止的索引为正为负，默认都是从左向右取的。那么想要切片从右往左取，就可以通过规定步长来实现。

names[start:end:step] 在没有规定step是默认为1。

names=['alex', 'eric', 'mjj', 'peiqi', [1,2,3],23, 24, 25]
a = names[1:5:2]  # 每步长为2取一个
print(a)  # a为['eric','peiqi']  

b = [::-1]  # 通过规定步长为-1，就可以实现列表的倒序排列
print(b)  # b = [25, 24, 23, [1, 2, 3], 'peiqi', 'mjj', 'eric', 'alex']

(5)排序

# sort() 方法使列表从小到大排列
a = [83,4,2,4,6,19,33,21]
a.sort()
print(a)  # a为[2, 4, 4, 6, 19, 21, 33, 83]

# sort(key,reverse) 里面两个参数
# key 参数用来指定根据哪个元素来比较 排序 ， reverse 就是倒序
info = [['alex',10], ['eric',20'],['mjj',2]]
info.sort(key = lambda x : x[1])  # 根据列表中每个元素的第二个元素排序
# 结果 info = [['mjj',2],['alex',10], ['eric',20']]

#如果含有特殊字符或者多个字符，会按照第一个字符的ascii码值排序
names=['金角大王', 'rain', '@', '黑姑娘', '狗蛋', "4","#",'银角大王', 'eva']
names.sort()
print(names)  # ['#', '4', '@', 'eva', 'rain', '狗蛋', '金角大王', '银角大王', '黑姑娘']

#reverse()方法，可以实现列表的反转
names.reverse()
print(names)
# names =['黑姑娘', '银角大王', '金角大王', '狗蛋', 'rain', 'eva', '@', '4', '#']

(6)循环列表

循环列表一般用for循环。

numbers = [1, 2, 3, 4, 5]
for i in numbers:
    print("number=",i)
#运行结果：
    number= 1
    number= 2
    number= 3
    number= 4
    number= 5

元组

元组又被称为只读列表，不能修改。

(1)定义：与列表相似，不过[ ]改为()。

(2)特点：可存放多个值；元素不可变；按照从左到右的顺序定义元组元素。

(3)元组常用操作:

#创建
a = (11, 12 ,13, 14)
#或
b = tuple((11, 12 ,13, 14))

ages = (11, 22, 33, 44, 55)
c=ages[0]
d=ages[-1]
print(c,d)  # c为11 ,d为55

#切片:同列表　　
#循环:同列表

#len方法查看长度（元素个数）
>>> len(ages)
5

#包含
print(11 in ages)  # True
print(66 in ages)  # False
print(11 not in ages)  # False

注意：元组本身不可变，如果元组中还包含其他可变元素，这些可变元素可以改变。

不可变元素如数字，字符串，可表元素如字典，列表。

data=(99, 88, 77, ['Alex', 'Jack'], 33)
data[3][1]='eric'
print(data)  # (99, 88, 77, ['Alex', 'eric'], 33)

因为元组只是存每个元素的内存地址，上面[‘金角大王’, ‘Jack’]这个列表本身的内存地址存在元组里确实不可变，但是这个列表包含的元素的内存地址是存在另外一块空间里的，是可变的。

字符串

(1)定义：字符串是一个有序的字符的集合，用于存储和表示基本的文本信息,' ' , ''  '' , '''  ''',中间包含的内容称之为字符串。

(2)特性: 按照从左到右的顺序定义字符集合，下标从0开始顺序访问; 可以进行切片操作;

不可变，字符串是不可变的，不能像列表一样修改其中某个元素，所有对字符串的修改操作其实都是相当于生成了一份新数据。

(3)字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r'l\thf'。

注意：对字符串的操作方法并不改变原字符串。

(4)字符串的常用操作

names='alex Li'

names.capitalize()  # 首字母大写 Alex Li

names.casefold()  # 把字符串全变小写 alex li

names.center(20,'-')  # ------alex Li-------

names.count('字符',start,end)  # 找出在规定范围内字符出现的个数

names.endcode()  # 编码

names.endwith()  # 判断字符串以什么结尾

names.startwith()  # 判断字符串以什么开始

name.find()  #  找到这个字符返回下标，多个时返回第一个；不存在的字符返回-1

name.index()  # 找到这个字符返回下标，多个时返回第一个；不存在的字符报错

name.format()  # 字符串格式化
s1 = "Welcome {name} to Apeland,you are No.{user_num} user."
print(s1.format(name="Alex", user_num=999))
#结果Welcome Alex to Apeland,you are No.999 user

bb = "luffy"
print(f'my name is {bb}') # my name is bb  f'为fromat 简写

names.isdigit()  # 判断字符串是否都是数字，返回一个布尔值

names.isspace() #是否全是空白字符

names.islower() #S中的字母是否全是小写
names.isupper() #S中的字母是否便是大写
names.istitle() #S是否是首字母大写的

n = ['alex','jack','rain']
print('|'.join(n))  #  结果为'alex|jack|rain'
#' strs'.join(n)  用字符串连接n 使n成为一个字符串 ，n可以为字符串。

names.lower()  # 将字符串全部小写
names.upper()  # 将字符串全部大写

names.swapcase()  # 返回大小写转换后的字符串

names.ljust(width,char)  # 返回一个原字符串向左对齐，指定长度的字符串，长度不够# 用指定的字符来补，超过则自动加长
names.rjust(width,char)  # 向右对齐，其余同上

names.strip()  # 去掉左右的空格和换行符
names.lstrip()  # 去掉左边的空格和换行符
names.rstrip()  # 去掉右边的空格和换行符

names.strip(str)  # 去掉指定的字符

names.replace(oldstr,newstr)  # 字符串替换

names.split()  # 默认以空格分割成一个列表，也可指定字符分割

names.zfill(width)  # 指定字符串长度，向右对其，长度不够补0

字典

(1)定义：通过键值对的形式{ key1: value1, key2: value2}

ex :  user_info = {

　　'name': 'alex',

　　　　'age': 24;

　　　　'hobby': 'have fun with girls'

　　　　　　　　}

(2)特性:

1. key-value结构。

2. key必须为不可变数据类型、必须唯一。

3. 可存放任意多个value、可修改、可以不唯一。

4. 排列无序。

5. 查询速度快。

 (3)字典的创建及常用操作

创建

#直接通过大括号创建
person = {"name": 'alex', 'age': 20} 

#dict方法
person = dict(name='seven', age=20)
#或
person = dict({"name": "egon", 'age': 20})

#批量创建key时, 用{}.fromkeys([key1,key2,key3],n)     其中key为键名，n为默认值
a={}.fromkeys([1,2,3,4],100)
print(a)  # 运行结果： {1:100, 2:100, 3:100, 4:100}

增

user_info = {'name': 'alex', 'age': 23, 'sex': 'male}
#添加一组键值对
user_info['hobby'] = 'girls'
print(user_info)
# user_info = {'name': 'alex', 'age': 23, 'sex': 'male,'hobby': 'girls'}

#setdefault()方法
#user_info.setdefult("key",value)
# 如果字典user_info中没有key，则在字典中添加该键值#对，并返回value的值；
#如果字典中用这个key，则返回字典中key对应的值，原来字典中的值不作修改。

删

person = {'alex': 'boss', 'wupeiqi': 'manager', 'egon': 'staff' }
#pop()方法
person.pop('egon')  # 删除指定的键值对
print(person)  # person = {'alex': 'boss', 'wupeiqi': 'manager'}

#popitem()
person = {'alex': 'boss', 'wupeiqi': 'manager', 'egon': 'staff' }
person.popitem()  # popitem()方法随机删除一组键值对，所以person可能有多个值
print(person)

#del方法
del person['wupeiqi']  # del什么都可以删,包括字典本身。
print(person)  # person =  {'alex': 'boss', 'egon': 'staff' }

#clear
person.clear()  # 清空字典
print(person)  # person={}

改

#通过key来修改
person = {'alex': 'boss', 'wupeiqi': 'manager', 'egon': 'staff' }
person['egon'] = '弟弟'
print(person)  # person = {'alex': 'boss', 'wupeiqi': 'manager', 'egon': '弟弟' }

#update方法
dic1 = {'name':'alex', 'age':23, 'sex':'male'}
dic2 = {'sex':'female','hobby':'girls'}
dic1.update(dic2)
print(dic1)  # dic1={'name': 'alex', 'age': 23, 'sex': 'female', 'hobby': 'girls'}
#update方法就是dic1和dic2合并成为一个字典，当dic1和dic2有相同的key时，
#key的值会进行覆盖，update()里面的覆盖外面的，即dic2覆盖dic1.

查

#通过key查找,dic[key],存在则返回相对应的值，不存在则报错。
person = {'alex': 'boss', 'wupeiqi': 'manager', 'egon': 'staff' }
a = person['alex']
print(a)  # a = 'boss'

#get方法查找，dic.get(key, default) 返回key对应的值，若不存在，则返回默认值
b = person.get('wupeiqi')  # default可以不写，默认为None
print(b)  # b = 'manager'
c = person.get('mjj', 'cleaner')  # 可以设置默认值
print(c)  # c = 'cleaner' 

#dic.keys()  返回一个包含所有key的列表
#dic.values() 返回一个包含所有values的列表 ，但不能像列表一样操作，因为数据类型不同
keys = person.keys()  # dict_keys(['alex', 'wupeiqi', 'egon'])
values = person.values()  # dict_values(['boss', 'manager', 'staff'])

#dic.items()  返回一个包含所有（键，值）元组的列表
item = person.items()
#  dict_items([('alex', 'boss'), ('wupeiqi', 'manager'), ('egon', 'staff')])

(4)字典的循环

#1、for k in dic.keys()
# k就是key的值

#2、for k,v in dic.items()
#用两个参数k,v接收，k为key的值，v为value的值

#3、for k in dic   # 推荐用这种，效率速度最快 k仍为key，当想取值时，用 dic[k] 即可

(5) 求字典长度

len(dic):求出字典中键值对的个数。

集合

(1)定义：集合与列表相似，可以存放不同的数据类型，但与列表也有不同之处。

(2)特性：

　　1.天生去重，集合中不能有重复的元素。

　　2.无序，不像元素在列表中通过索引来排列，集合中的元素时没有顺序的，即{3，4，5}与{5，3，4}是同一个集合。

　　3.集合中的元素不可变，即不能存放列表，字典，数字、字符串、元组这些不可变的类型可以存入集合。

综合以上特性，集合可以用来做两件事情，去重和关系运算。

(3)集合的语法及常用操作

创建

#集合和字典相似，都是通过{}创建,不过集合没有键值对。
a={1,2,3,4,'alex','wupeiqi','egon',1,2,3,4,5}
print(a)  # a={1,2,3,4,5,'alex','wupeiqi','egon} ，由此可见集合的去重特性

#通过集合去重的特性，我们可以帮列表去重。
b = [1, 2, 3, 4, 2, 'alex', 3, 'rain', 'alex']
a = set(b)  # a={1, 2, 3, 4, 'alex', 'rain'}
b = list(a)  # b =[1, 2, 3, 4, 'alex', 'rain']
#上述过程就是将b转换成集合，去重后，在转换为列表，整个过程通过一句代码就可以搞定。
b = list(set(b))  #效果与上面的三句相同

增删查：集合元素不能修改

a = { 1,2,3,4,'alex','wupeiqi'}
#增加元素，用add()方法
a.add('mjj')
print(a)  # a ={1, 2, 3, 4, 'alex', 'mjj','rain'}

#删除元素，有三种方法
#a.pop() 随机删除一个元素并返回

#a.discard() #删除指定元素，如果该元素不存在，则什么都不做。

#a.remove()  # 删除指定元素，如果该元素不存在，则报错。

#查
print(a)  # 查看整个集合
print(4 in a)  # 通过in 、not in 方法判断元素是否在集合中

(4)关系运算:两个集合之间一般有三种关系，相交、包含、不相交。

s_1024 = {"peiqi","oldboy","rain","mjj"}
s_pornhub = {"Alex","Egon","rain"}

print(s_1024&s_pornhub)#求交集
# {'rain}

print(s_1024|s_pornhub)#求并集
# {"peiqi","oldboy","rain","mjj","Alex","Egon"}

print(s_1024-s_pornhub)#求差集 只在s_1024中的元素
# {"peiqi","oldboy","mjj"}

print(s_pornhub-s_1024)#只在s_pronhub中的元素
# {"Alex","Egon"}

print(s_1024^s_pornhub)#将两个集合的共同元素除去 并将剩下的元素进行拼接
# {"peiqi","oldboy","mjj","Alex","Egon"}

print(s_1024.isdisjoint(s_pornhub)) #判断两个集合是否不相交
# False 两个集合有交集

print(s_1024.issubset(s_pornhub))#判断 s_1024是否为s_pronhub的子集
# False

print(s_1024.issuperset(s_pornhub))#判断s_1024是否为s_pronhub的父集
# False

#s_1024^s_pornhub 这种关系运算并不改变原来两个集合本身
s_1024.difference_update(s_pornhub)#除去共同元素 并改变原集合
print(s_1024)
# {"peiqi","oldboy","mjj"}

这里我们来做一下总结。

首先我们来了解一下什么是可变数据类型与不可变数据类型。

可变类型就是数据的值改变，但是其内存地址不改变。

不可变数据类型就是数据的值改变，它的内存地址也会改变。

python中的数据类型中，

不可变数据类型：数字，字符串，元组。

可变数据类型：列表，字典，集合。

注：以上内容部分参考自路飞学城。