字符串,列表,元祖,字典

python数据类型

字符串

类型：python中的数据类型

特性：字符串是不可变对象,所以不能修改

格式

1.字符串，用引号引起来的就是字符串:'',"",''' ''' ,""" """ 

str1= 'hello'

#str2='It's OK'  #错误的方法,引号直接要有区分

str2="It's OK"   #正确的方法

执行结果
hello
报错:SyntaxError: invalid syntax （表示代码中语法错误）
It's OK

2.三引号，有两种写法，三个单引号'''''',三个双引号"""""".都可以用，不可以混合用，还可以换行，单引号换行时，都需要加\n,只占一个字符

str3 = '''床前明月光
疑似地上霜
举头望明月
低头思故乡'''
print(str3)
执行结果:
床前明月光
疑似地上霜
举头望明月
低头思故乡
 

print(len('\n'))  #查询字符长度,有转义符,所以长度为1
print(len('R\n')) #执行结果长度为2,因为在字符串前加了r,转义符串不生效

 

3.字符串的转义符

#有\转义符的时候，可以多加一个\,或者 在字符串前面加个r，表示后面的字符串中所有转义符均不生效

print(len('\n'))  #查询字符长度,有转义符,所以长度为1

print(len('R\n')) #执行结果长度为2,因为在字符串前加了r,转义符串不生效 

filepath ='D:\session.txt'
print(filepath)

filepath ='D:\\session.txt'
print(filepath)

filepath =r'D:\session.txt'
print(filepath)

filepath =r'D:/session.txt'
print(filepath)   #操作系统中的路径使用的时候可以用正斜杠 /

4.字符串的拼接

print('1'+'6')    #1和6拼接,执行结果是16，
print(1.1+6)      #1.1和6相加,执行结果7.1
print('1'*6)      #表示将字符串打印6次,执行结果是111111
print(1*6)        #1和6相乘,执行结果是6
print(2**6)       #**是2的6次方,执行结果是64 ,
print(6/2)        # 3.0
print(int(6/2))   #3
print(int(6/2.0)) #3
# print('1'+6)    #报错，两个不同类型，一个是字符串，一个是数字，无法拼接

执行结果:
16
7.1
111111
6
64
3.0
3
3

5.字符串的下标用法

str6='abcdefg'
print(str6[5])      #f 第5位是f
print(str6[-2])     #f 倒数第二位是f
print(str6)

执行结果:
f
f
abcdefg

6.字符串的切片用法

# 取str6的前3位    [起始值:终止值]，包含起始值，不包含终止值,缺省值为1
str6='abcdefg'
print(str6[0:3])    # 结果是abc   a是第0位，c是第二位，因为不包含终止值，所以要往后面取以为，取到第三位
print(str6[-7:-4])  #负下标的取法
print(str6[:-4])    #起始值不写，表示从头开始取，
print(str6[:3])     #起始值不写，表示从头开始取，


执行结果:
abc
abc
abc
abc


#取str6='abcdefg'的 cba    [起始值:终止值：步长]，包含起始值，不包含终止值，步长默认为1   终止值不写，表示取到后面所有的值
str6='abcdefg'
print(str6[2::-1])      #cba   从第二位开始走，一次走负一步,不包含终止值，如果终止值写0，就是cb了
print(str6[-5::-1])     #cba
print(str6[2::-2])      #ca    从第二位开始走，一次走负两步
print(str6[2::2])       #ceg   从第二位开始走，一次走正两步
print(str6[:])          #全部取值
print(str6[::2])        #打印的值为 aceg  从头开始取，取到最后一位，一次走两步
print(str6[::100])      #打印的值为a   此字符串总共7位，超过7位的步长就没有了

执行结果:
cba
ca
ceg
abcdefg
aceg
a


# 注意切片是一个新的对象，与原对象无关，不影响原对象的值
str6='abcdefg'
str6_new=str6[2:4]
print(str6)      #这是原对象:abcdefg
print(str6_new)  #切成新对象了  cd


执行结果:
abcdefg
cd

 

字符串的题目

a=5,b='6',请按照普通数学的方法计算a+b的值.

解释:print(a+b) 数字和字符串直接计算会报错 TypeError: unsupported operand type(s) for +: 'int' and 'str'

可以将对象转为整数型 int() 字符串中有小数是不能转成int(),可以转成float()将对象转成浮点型 str()将对象转为字符串

a=5
b='6'
c=a+int(b)

print(a+int(b))
print(c)


执行结果:
11

　　

 

字符串的用法

# coding:utf-8
a = 'Hello World!'
print(a.capitalize())   # 首字符大写
print(a.casefold()) # 大写全部变小写
print(a.center(20,'+')) # 两边填充‘+’
print(a.count('l')) # 统计
print(a.endswith('ld!'))    # 判断已XXX结尾
print(a.encode())   # 解码成bytes格式
print(a.find('H'))  #返回X的坐标
print(a.index('e')) # 返回第一个X的下标
print(a.isdigit())  # 返回是否一个整数
print(','.join(['1','2','3']))  # 已,进行分割    列表转换为字符串
print(a.swapcase()) # 大小写互换
b = 'Hello World! {}'
print(b.format('name'))    # 补充，可以对应参数

执行结果：
Hello world!
hello world!
++++Hello World!++++
3
True
b'Hello World!'
0
1
False
1,2,3
hELLO wORLD!
Hello World! name

 

列表

类型：python中的数据类型

特性：

列表类似于java中的数组，可以放任意类型的对象，用[]括起来的

   列表是可变对象,可以增删改查

格式：

list1=[1,'abc',[10,20],{'A':'apple'}]
print(list1)

执行结果:[1, 'abc', [10, 20], {'A': 'apple'}]        #可以放字符串,列表,字典

 

列表的增删改

#改变元素
list2=[10,20,30,40,50]
list2[0]=198   #把第0位改成198
print(list2)

执行结果:[198, 20, 30, 40, 50]


#增加元素
list2=[10,20,30,40,50]
list2.append(60)  #将60加到list2的末位,append的是永远加到列表最后一位
print(list2)

执行结果：
[10, 20, 30, 40, 50, 60]


#insert 增加到指定位置

list2=[10,20,30,40,50]
list2.insert(1,60) #将60加到list2的第一位，(1是下标,60是值)    如果加的位置超过本身的长度，就会加到最后一位
print(list2)

执行结果；[10, 60, 20, 30, 40, 50]   解释：原来是[10,20,30,40,50]，第0位是10，第一位是20，现在60加到一位，60就是第一位 [198, 60, 20, 30, 40, 50, 60]


#extend 列表的拼接

list2_1=[100,200]
list2_2=[300,400]
list2_1.extend(list2_2)   #  list2_1与list2_2，打印list2_1 顺序换一下，执行的结果顺序就换，也可以自己拼接自己 ,列表和列表的拼接
print(list2_1

执行结果：
[100, 200, 300, 400]

list2_1=[100,200]
list2_2=[300,400]
list2_1.extend(list2_2)
print(list2_2)

执行结果：
[300, 400]

list2_1=[100,200]
list2_2=[300,400]
list2_2.extend(list2_2)
print(list2_2)

执行结果：
[300, 400, 300, 400]    #自己与自己拼接


#pop()删除列表中的元素 
list3=[1,2,3,4,5]
list3.pop()    #删除列表的最后一位
print(list3)

执行结果：
[1, 2, 3, 4]

#根据下标进行删除
list4=[1,2,3,4,5]
list4.pop(1)      #删除第1位
print(list4)

执行结果：
[1, 3, 4, 5]


#根据值进行删除
list5=[100,200,300,400,500,600,500]
list5.remove(500)
# list5.remove(500)
print(list5)

执行结果：
[100, 200, 300, 400, 600, 500]   #解释：指定删除500，有2个500，只删除第一个500，如果需要删除两个，写两遍


#del  没有加下标的时候，就会全部删除
list5=[100,200,300,400,500,600,500]
del list5[1]
#del list5  #无下标的写法
print(list5)

执行结果：
[100, 300, 400, 500, 600, 500]    #无下标执行会报错：NameError: name 'list5' is not defined

列表的切片  列表的切片是一个新的对象，不影响列表的值

list6=[11,22,33,44,55,66,77,88,99]
print(list6[-2::-1])

执行结果：[88, 77, 66, 55, 44, 33, 22, 11
解释：-2是起始值，冒号中间没有，就是指一直到最后，-1是步长（-1步）

列表的排序

正序永久排序
list1=[1,2,3,0,-1,-3,18,9]
list1.sort()     #不生成新对象，直接原对象修改
print(list1)

执行结果：
[-3, -1, 0, 1, 2, 3, 9, 18]


倒叙永久排序
list1=[1,2,3,0,-1,-3,18,9]
list1.sort(reverse=True)   #倒叙排序
print(list1)

执行结果：
[18, 9, 3, 2, 1, 0, -1, -3]




正序临时排序：
list1=[1,2,3,0,-1,-3,18,9]
list1_new=sorted(list1)     生成了新对象，原对象不变
print(list1_new)
print(list1)

执行结果：
[-3, -1, 0, 1, 2, 3, 9, 18]       #运行的结果是新值，修改过的排序
[1, 2, 3, 0, -1, -3, 18, 9]       #运行的结果是原来的


倒叙临时排序
list1=[1,2,3,0,-1,-3,18,9]
list1_new=sorted(list1,reverse=True)
print(list1_new)
print(list1)

执行结果：
[18, 9, 3, 2, 1, 0, -1, -3]
[1, 2, 3, 0, -1, -3, 18, 9]

 

 

用法

# coding:utf-8
name = ['ZhangSan','XiaoMing','LiSi','Tom','Boy']
print(name[0])  # 通过下标查看
print(name[-1]) # 倒着查
print(name[1:4])    # 下标中间的
print(name[:3]) # 从头开始 0可以忽略
print(name[::3])    # 没隔3个字符取
print(name.index('Tom'))    # 返回下标
name.append('Xiaodu')   # 增加
print(name)
name.insert(2,'Zifu')   # 根据下标进行添加
print(name)
name.pop(2)  # 根据坐标删除
print(name)
name.remove('LiSi') # 根据指定内容删除
print(name)
name[0]='22222' # 修改
print(name)
name.extend(['12','33'])    # 合并其他列表
print(name)

执行结果：
ZhangSan
Boy
['XiaoMing', 'LiSi', 'Tom']
['ZhangSan', 'XiaoMing', 'LiSi']
['ZhangSan', 'Tom']
3
['ZhangSan', 'XiaoMing', 'LiSi', 'Tom', 'Boy', 'Xiaodu']    # 增加
['ZhangSan', 'XiaoMing', 'Zifu', 'LiSi', 'Tom', 'Boy', 'Xiaodu']    # 怎加
['ZhangSan', 'XiaoMing', 'LiSi', 'Tom', 'Boy', 'Xiaodu']    # 删除
['ZhangSan', 'XiaoMing', 'Tom', 'Boy', 'Xiaodu']    # 指定内容删除
['22222', 'XiaoMing', 'Tom', 'Boy', 'Xiaodu']    # 修改
['22222', 'XiaoMing', 'Tom', 'Boy', 'Xiaodu', '12', '33']    # 合并

 

元祖

类型：python的数据类型

特性：元组与列表类似，都可以使用下标与切片，是不可变对象，不可以增删改

格式：

tuple1=(11,22,33,44,55,66,77,88)
print(tuple1[2:7:2])
print(type(tuple1))

执行结果：
(33, 55, 77)        #从第二位开始取，第6位结束，每次2步长
<class 'tuple'>     #查看类型

tuple2=(10)
print(type(tuple2))
执行结果：
<class 'int'>       #当元组中只有一个值的时候是int（整数）类型，不是元组类型，

tuple3=(10,)
print(type(tuple3))
执行结果：
<class 'tuple'>    #当元组中只有一个值的时候，加一个逗号，就是元组类型

 

元组中有子列表，可以修改值

#把子列表中的7改成10 题目：(1,2,3,4,5,[7,9])
#正下标
tuple4=(1,2,3,4,5,[7,9])
tuple4[5][0]=10
print(tuple4)

执行结果：(1, 2, 3, 4, 5, [10, 9])
解释：括号内的1,2,3,4,5是元组，[7,9]是子列表   ，现在把7改成10思路；先找到7在元组中是第几（5）位，然后在看7在子列表中是第几（0）位


#负下标
tuple4=(1,2,3,4,5,[7,9])
tuple4[-1][-2]=10
print(tuple4)

执行结果：(1, 2, 3, 4, 5, [10, 9])


查-2位是几？
tuple4=(1,2,3,4,5,[7,9])
print(tuple4[-2]) 

执行结果：5
解释：元组中有子列表的时候，元组的数据，一位一位正常算，[7,9]是子列表的中，所有的都只算一位

用法：

x = ("hello","world",'hello')
print(x.count('hello')) # 统计
print(x.index('world')) # 下标

执行结果：
2
1

 

类型：python数据类型

特性：可以修改，无序

格式：

#字典是无序的
dict1={'A':'小明字典','B':'小红字典'}
dict2={'B':'小红字典','A':'小明字典'}
print(dict1==dict2)         
print(dict2)

执行结果： 
True    #字典是无顺序的,只关注键值对所以这两个是相等的
{'B': '小红字典', 'A': '小明字典'}  

#字典的键是唯一的
dicta={'A':'apple','A':'ace'}
print(dicta)

执行结果:{'A': 'ace'}
解释:A先放了个apple,然后又放了ace进去,python认为输入了两次 ,先输入了apple,然后把apple又改成了ace

列表是有序的,列表的键具有唯一性
list1=['1','2']
list2=['2',[1]]
print(list1==list2) 

执行结果：False

字典的增删改

#字典的更新
dictb={'A':'苹果'}
dictb['A']='香蕉'       #更新语句   #{'A': '香蕉'}
dictb['B']='梨'         #新增      {'A': '香蕉', 'B': '梨'}
print(dictb['A']) 
print(dictb['B'])

执行结果:
香蕉
梨


#updat(),新增或修改多个键值对
dictb={'A':'苹果'}
dictb.update({'A':'橙子','B':'香蕉','C':'草莓'})
print(dictb)

执行结果:
{'A': '橙子', 'B': '香蕉', 'C': '草莓'}


# #删除字典中的键值对
dictb={'A':'苹果','B':'火龙果'}
del dictb['A']
# del dictb['B']
print(dictb)

执行结果:{'B': '火龙果'}
#同时删除A和B,就要写两次,结果为{}


#清空字典
dictc={'A':'小明字典','B':'小红字典'}
print(id(dictc))
dictc.clear()        #内存中的地址不会
print(id(dictc))
print(dictc)

执行结果:
2431342508936    #查到的内存
2431342508936
{}                        #清空了字典


重新赋空值
dictc={'A':'小明字典','B':'小红字典'}
# print(id(dictc))
dictc={}     
print(dictc)

执行结果:{}           #重新赋值个空字典,这个时候内存中的字典就变化的

 

遍历字典

#遍历键
dict9 = {'A':'BOOK','B':'BIKE','C':'CAKE'}
for k in dict9.keys():
    print(k)

执行结果:
A
B
C


#遍历值
dict9 = {'A':'BOOK','B':'BIKE','C':'CAKE'}
for v in  dict9.values():
    print(v)

执行结果:
BOOK
BIKE
CAKE


#遍历键值对
dict9 = {'A':'BOOK','B':'BIKE','C':'CAKE'}
for k,v in dict9.items():
    print(k,v)

执行结果:
A BOOK
B BIKE
C CAKE

题目:判断某个对象是否在字典中???根据键判断是ture,根据值判断是flase

dict10 = {'A':'BOOK','B':'BIKE','C':'CAKE'}
print('A' in dict10)          
print('BOOK' in dict10)

执行结果:
True       #根据键判断是ture
False      #根据值判断是flase


#josn格式,非常像字典的字符串
str='''{
"acc033":"张三",
"acc030":"13543434543",
"crm003":"1",
"crn004":"1"}'''
print(str[1:38])

执行结果:
"acc033":"张三",
"acc030":"13543434543  #从第1位打印到第38位


#将json转为字典
str='''{
"acc033":"张三",
"acc030":"13543434543",
"crm003":"1",
"crn004":"1"}'''
import json
str_new=json.loads(str)   #将json转为字典
print(str_new['acc033'])

执行结果:张三 

#将字典转化为json

不会,先放着

用法

# coding:utf-8
a = {
    'cuid01':"zhangsan",
     "cuid02":"lisi",
    "cuid03":"mazi"
}
a["cuid04"] ='tianqi'   # 字典添加
print(a)
a["cuid01"] = 'wangwu'  # 字典修改
print(a)
print(a.get("cuid02"))  # 查找
#a.pop("cuid01") # 删除
del a['cuid01'] # 删除
print(a)
b = {
    'cuid05':'sssss'
}
a.update(b) # 增加
print(a)
a.setdefault('cuid','sssss')    # 增加
print(a)


执行结果：
{'cuid01': 'zhangsan', 'cuid02': 'lisi', 'cuid03': 'mazi', 'cuid04': 'tianqi'}
{'cuid01': 'wangwu', 'cuid02': 'lisi', 'cuid03': 'mazi', 'cuid04': 'tianqi'}
lisi
{'cuid02': 'lisi', 'cuid03': 'mazi', 'cuid04': 'tianqi'}    # 删除
{'cuid02': 'lisi', 'cuid03': 'mazi', 'cuid04': 'tianqi', 'cuid05': 'sssss'} #增加    
{'cuid02': 'lisi', 'cuid03': 'mazi', 'cuid04': 'tianqi', 'cuid05': 'sssss', 'cuid': 'sssss'}    # 增加