可变和不可变类型
如果值改变，但是内存地址不变，证明就是在改变原值，即原值可变
如果值改变，但是内存地址也变了，证明不是在改变原值，而是产生了新的值，即原值不可变
# 定义方式
age = 18 # age = int(18)
print(type(age))
# int数据类型转换
res = int(" 18 ")
print(res,type(res))
# 常用操作+内置的方法
# 算数运算+比较运算
## 存一个值
# 不可变类型
# 2、定义方式
salary = 3.33 # salary = float(3.33)
# float数据类型转换
res = float(" 1.8 ")
print(res,type(res))
# 3、常用操作+内置的方法
# 算数运算+比较运算
# 存一个值
# 不可变类型
3.1定义和类型转换
# 2、定义方式
name = "egon" # name = str("egon")
# str数据类型转换：可以把任意类型都转换成字符串类型
res = str([1,2,3])
print(res,type(res))
# "[1,2,3]"
# 存一个值
# 不可变类型
#有序
3.2 索引
按索引取值(正向取+反向取) ：
msg = 'hello world'
print(msg[4])
print(msg[5])
print(msg[-1])
#运行结果
o
d
3.3切片
切片(顾头不顾尾，步长)：从一个大字符串中拷贝出一个子字符串
msg = 'hello world'
res1 = msg[1:5:2]
res2 = msg[1:5]
res3 = msg[1:]
res4 = msg[:]
res5 = msg[-1:-4:-1]
res6 = msg[-1::-1]
res7 = msg[::-1] # 将字符串颠倒
print(msg)
print(res1)
print(res2)
print(res3)
print(res4)
print(res5)
print(res6)
print(res7)
#运行结果
hello world
el
ello
ello world
hello world
dlr
dlrow olleh
dlrow olleh
进程已结束，退出代码为 0
3.4长度
#长度len
msg = 'hello world'
print(len(msg))
#运行结果
11
进程已结束，退出代码为 0
3.5 成员运算in和not in
str1 = 'hello python!'
# in:判断hello 是否在 str1里面
'hello' in str1
#运行结果
True
# not in:判断tony 是否不在 str1里面
'tony' not in str1
#运行结果
True
3.6 移除 strip()
name = ' eg on '
print(name.strip())
#运行结果
eg on
进程已结束，退出代码为 0
name = '*****eg on****'
print(name.strip('*'))
#运行结果
eg on
进程已结束，退出代码为 0
msg = "*(&%&%&_+)**&^e*gon*)(^%$$&$"
print(msg.strip('*()&%_+^%$'))
#运行结果
e*gon
进程已结束，退出代码为 0
l1="*****egon*****"
print(l1.strip("*"))#移除两边的*
print(l1.lstrip("*"))#移除左边的*
print(l1.rstrip(("*")))#移除右边边的*
#运行结果
egon
egon*****
*****egon
进程已结束，退出代码为 0
3.7 replace()方法
x = 'a c d e'
print(x.replace(' ','',1))# 替换一次
print(x.replace(' ','')) #默认全部替换
#运行结果
ac d e
acde
3.8 切分 split()
# 6.1 括号内不指定字符，默认以空格作为切分符号
msg = "egon:18:male:10"
res = msg.split(':')
print(res)
#运行结果
['egon', '18', 'male', '10']
# 括号内指定分隔字符，则按照括号内指定的字符切割字符串
# 注意:split切割得到的结果是列表数据类型
3.9拼接 join()
info = ['111', '222', '333', '444']
msg = ":".join(info)
print(msg)
#运行结果
111:222:333:444
3.10 循环
str1='hello world'
for x in str1:
print(x)
#运行结果
h
e
l
l
o
w
o
r
l
d
进程已结束，退出代码为 0
3.11. lower(), upper()
>>> str2 = 'My nAme is tonY！'
>>> str2.lower() # 将英文字符串全部变小写
my name is tony！
>>> str2.upper() # 将英文字符串全部变大写
MY NAME IS TONY！
3.12 格式化输出之format
# format括号内在传参数时完全可以打乱顺序，但仍然能指名道姓地为指定的参数传值，name=‘tony’就是传给{name}
str4 = 'my name is {name}, my age is {age}!'.format(age=18,name='tony')
print(str4)
#运行结果
'my name is tony, my age is 18!'
str4 = 'my name is {name}{name}{name}, my age is {name}!'.format(name='tony', age=18)
print(str4)
#运行结果
'my name is tonytonytony, my age is tony!'
3.13 isdigit()
isdigit() 方法检测字符串是否只由数字组成。
str = "123456";
print str.isdigit();
#运行结果
True
str = "this is string example....wow!!!";
print str.isdigit();
#运行结果
False
4.1定义和类型转换
#定义方式：在[]用逗号分隔开多个任意类型的元素
l = [111,33.333,"aaaa",[666,7777]] # l = list(...)
print(type(l))
#运行结果
<class 'list'>
#list数据类型转换
res = list("hello")
print(res)
#运行结果
['h', 'e', 'l', 'l', 'o']
# 存多个值
# 有序
# 可变类型
4.2 索引
l = [111,222,333,444,555,666,777]
print(l[0])
print(l[-1])
#运行结果
111
777
4.3、切片
l = [111,222,333,444,555,666,777]
print(l[1:4:1]) # 拷贝
print(l[:])
print(l[::-1])
#运行结果
[222, 333, 444]
[111, 222, 333, 444, 555, 666, 777]
[777, 666, 555, 444, 333, 222, 111]
4.4、长度
l = [111,222,333,444,555,666,777]
print(len(l))
#运行结果
7
4.5 成员运算in和not in
l = [111,222,333,444,555,666,777]
print(333 in l)
#运行结果
True
4.6、追加、插入
#追加append
l = [111,222,333,444,555,666,777]
l.append(888)
print(l)
#运行结果
[111, 222, 333, 444, 555, 666, 777, 888]
#插入insert
l = [111, 222, 333, 444, 555, 666, 777]
l.insert(3, 999999999999)
print(l)
#运行结果
[111, 222, 333, 999999999999, 444, 555, 666, 777]
4.7 删除
l = [111, 222, 333, 444, 555, 666, 777]
#（1）万能删除
del l[1]
print(l)
#运行结果
[111, 333, 444, 555, 666, 777]
# (2) l.remove()
l = [111, 222, 333, 444, 555, 666, 777]
v = l.remove(333)
print(l)
print(v)
#运行结果
[111, 222, 444, 555, 666, 777]
None
# (3) l.pop()
l = [111, 222, 333, 444, 555, 666, 777]
v = l.pop(2)
print(l)
print(v)
#运行结果
[111, 222, 444, 555, 666, 777]
333
4.8 循环
# 7、循环
l = [111,222,333,444]
for i in l:
print(i)
#运行结果
111
222
333
444
4.9 大小比较 sort()
l1 = [111, -3, 99, 27]
l1.sort() #默认从小到大
print(l1)
#运行结果
[-3, 27, 99, 111]
l1 = [111, -3, 99, 27]
l1.sort(reverse=True )
print(l1)
#运行结果
[111, 99, 27, -3]
4.10 颠倒列表
# 7.reverse()颠倒列表内元素顺序
>>> l = [11,22,33,44]
>>> l.reverse()
>>> l
[44,33,22,11]
# ======================================元组基本使用======================================
# 1、用途：元组就是一种不可变的列表
# 2、定义方式：在()内用逗号分割开多个任意类型的元素
# t = (11,11.333,"aaa",[666,777]) # t = tuple()
# tuple数据类型转换
# print(tuple("hello"))
# 3、常用操作+内置的方法
# 优先掌握的操作：
# 1、按索引取值(正向取+反向取)：只能取
# 2、切片(顾头不顾尾，步长)
# 3、长度
# 4、成员运算in和not in
# ======================================该类型总结====================================
# 存多个值
# 有序
# 不可变
定义方式：在{}内用逗号分割开多个元素，每个元素都是key:value的形式 其中value可以是任意类型，而key必须是不可变类型，通常是字符串类型
定义形式
dic = {1:111111,33.33:"aaa",(1,2,3):'bbbb'} # dic = dict(...)
# dict数据类型转换
dic = dict([('name','egon'),('age',18)])
print(dic)
#运行结果
{'name': 'egon', 'age': 18}
6.1常用操作+内置的方法
# 1、按key存取值：可存可取
# dic = {'name': 'egon', 'age': 18}
# print(dic['name'])
# print(dic['name1'])
# print(dic.get('name'))
# print(dic.get('name1'))
# dic['gender'] = 'male'
# print(dic)
# dic = {'name': 'egon', 'age': 18,'name':"tom",'name':'lili'}
# print(dic)
# 2、长度len
# dic = {'name': 'egon', 'age': 18}
# print(len(dic))
# 3、成员运算in和not in
# dic = {'name': 'egon', 'age': 18}
# print('name' in dic)
# 4、删除
# 万能删除
# del dic['name']
# print(dic)
# dic.pop()
# v = dic.pop('name')
# print(v)
# dic.popitem()
# res = dic.popitem()
# print(res)
# 5、键keys()，值values()，键值对items()
"""
>>> dic = {'name': 'egon', 'age': 18}
>>>
>>>
>>> dic.keys()
['age', 'name']
>>>
>>> dic.values()
[18, 'egon']
>>>
>>> dic.items()
[('age', 18), ('name', 'egon')]
"""
# 6、循环
# dic = {'name': 'egon', 'age': 18}
# # for k in dic.keys():
# # print(k)
#
# # for k in dic:
# # print(k)
#
# # for v in dic.values():
# # print(v)
#
# for k,v in dic.items():
# print(k,v)
需要掌握的操作
1.get()
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.get('k1')
'jason' # key存在，则获取key对应的value值
>>> res=dic.get('xxx') # key不存在，不会报错而是默认返回None
>>> print(res)
None
>>> res=dic.get('xxx',666) # key不存在时，可以设置默认返回的值
>>> print(res)
666
# ps:字典取值建议使用get方法
2.pop()
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> v = dic.pop('k2') # 删除指定的key对应的键值对,并返回值
>>> dic
{'k1': 'jason', 'kk2': 'JY'}
>>> v
'Tony'
3.popitem()
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> item = dic.popitem() # 随机删除一组键值对,并将删除的键值放到元组内返回
>>> dic
{'k3': 'JY', 'k2': 'Tony'}
>>> item
('k1', 'jason')
4.update()
# 用新字典更新旧字典，有则修改，无则添加
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.update({'k1':'JN','k4':'xxx'})
>>> dic
{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}
5.fromkeys()
>>> dic = dict.fromkeys(['k1','k2','k3'],[])
>>> dic
{'k1': [], 'k2': [], 'k3': []}
6.setdefault()
# key不存在则新增键值对，并将新增的value返回
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k3',333)
>>> res
333
>>> dic # 字典中新增了键值对
{'k1': 111, 'k3': 333, 'k2': 222}
# key存在则不做任何修改，并返回已存在key对应的value值
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k1',666)
>>> res
111
>>> dic # 字典不变
{'k1': 111, 'k2': 222}
集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算
集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
# 2、定义方式：在{}内用逗号分隔开多个元素，集合元素的特点如下
# 1、集合内元素不能重复
# 2、集合内的元素必须是不可变类型
# 3、集合内的元素无序
集合的运算
# pythons = {'张三', '李四', '王五', '刘6', 'egon', 'lili', '李建国'}
# linuxs = {'铁蛋', '铜蛋', '钢弹', 'egon', '狗蛋', 'lili'}
# print(pythons|linuxs) #并集
# print(pythons&linuxs) #交集
# print(pythons-linuxs)#差集
#print(pythons^linuxs)# 对称差集(^) 除了两边同时拥有的元素
父子集
# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True
# 6.2 不存在包含关系，则返回False
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False
# 7.子集
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True
集合去重复有局限性
# 1. 只能针对不可变类型
# 2. 集合本身是无序的，去重之后无法保留原来的顺序
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
