字符串类型

字符串只能存一个值，有序，不可变

当前阶段重点

strip() 移除空白，去除指定字符串
只能去除开头或结尾的连续字符串，中间的无法去掉，默认是去除空格，（）里面可以写其它字符串

#举例一password=input('>>> ')#第一种用法# password=password.strip()# print(password)#第二种用法#print(password.strip())#举例二msg='***dzm*****'print(msg.strip('*'))dzm

split()切分，以某一个指定的字符串，将一长串字符切分成一个列表，默认按照空格切分
split()有两个主要的参数，第一个是指定分割符，第二个是切成几段

#举例一user_info='root:0:0::/root:/bin/bash'print(user_info.split(':'))['root', '0', '0', '', '/root', '/bin/bash']print(user_info.split(':')[0])root#举例二 指定切几次print(user_info.split(':',1))['root', '0:0::/root:/bin/bash']#举例三user_list='root:x:0:0::dafeaefa'print(user_list.split(':')[0])root

#join 将列表使用指定字符拼接成一个字符串，可以用空格

user_list='root:x:0:0::dafeaefa'l=user_list.split(':')print(l)['root', 'x', '0', '0', '', 'dafeaefa']print(':'.join(l))root:x:0:0::dafeaefaprint(''.join(l))rootx00dafeaefa

拼接出unix风格路径

dirs = '', 'usr', 'bin', 'env'print('/'.join(dirs))结果：/usr/bin/env

拼接出DOS风格路径

print('C:' + '\\'.join(dirs))结果：C:\usr\bin\env

#判断数字
#在python3中
#isdigit 判断字符串里面是不是纯数字

num1=b'4' #bytesnum2=u'4' #unicode,python3中无需加u就是unicodenum3='四' #中文数字num4='肆' #中文繁体num5='Ⅳ' #罗马数字print(num1.isdigit())print(num2.isdigit())print(num3.isdigit())print(num4.isdigit())print(num5.isdigit())TrueTrueFalseFalseFalse

需要了解

移除左右空白

msg='***dzm*****'# print(msg.lstrip('*')) #只切掉左边的# dzm*****#print(msg.rstrip('*'))#只切掉右边的#***dzm

判断已什么开头和已什么结尾，输出结果是布尔值

msg='dzm_good'# print(msg.startswith('dzm'))# True# print(msg.endswith('good'))# True

方法replace将指定子串都替换为另一个字符串，并返回替换后的结果
替换字符串，第一个值为被替换的字符串，第二个为替换后的，第三个值为替换几个，不写为全部替换
替换字符串并不会改变原来的变量赋值，而是得到一个新的字符串

msg='my name is dzm , dzm is my'print(msg.replace('dzm','mdz'))my name is mdz , mdz is myprint(msg.replace('dzm','mdz',1))my name is mdz , dzm is my

format 类似格式化输出，但可以让你不再依赖位置去传值

#第一种用法# print('my name is {},my age is {}'.format('dzm',18))# my name is dzm,my age is 18#第二种用法# print('{0},{1},{0}'.format('dzm', 18))# dzm,18,dzm#第三种用法，不依赖位置# print('my name is {x},my age is {y}'.format(x='dzm',y=18))# my name is dzm,my age is 18

#find 从左到右找，如果有，返回第一个字符的索引
#如果找不到返回-1
#可以用来判断有没有匹配字符串，也可以指定范围找（顾头不顾尾）
#还有个rfind，是从右往左找

msg='hello,world'print(msg.find('ell'))1print(msg.find('l',0,5))2

index 索引，从左到右找，如果有，返回第一个字符的索引
纯找索引，找不到会报错
还有个rindex，是从右往左找

msg='hello,world'# print(msg.index('ell'))# 1print(msg.index('dzm'))#找不到，直接报错print(msg.index('l',4,8)) #也可以指定范围找（顾头不顾尾）

count统计有多少个字符串

# msg='hello,world'# print(msg.count('l'))# 3# print(msg.count('l',0,4))# 2

#center ljust rjust zfill 四个都是填充功能
让指定字符串居中显示，两边按总长度自动填充指定字符
#ljust，rjust 在左边填充和在右边填充
#有两个参数，第一个是指定字符串长度（宽度），第二个是用什么填充

#print('dzm'.center(30,'=')) #=============dzm==============# print('dzm'.ljust(30,'='))# dzm===========================# print('dzm'.rjust(30,'='))# ===========================dzm#zfill从左边用0填充print('dzm'.zfill(30))000000000000000000000000000dzm

#capitalize 首字母大写

msg='my name is dzm'

#upper 全部变成大写

print(msg.upper())MY NAME IS DZM

#lower 全部转换成小写

msg='My name is DZM'print(msg.lower())my name is dzm

#判断是否全部大写或全部小写

msg='My name is DZM'print(msg.isupper()) #判断是否全部是大写Falseprint(msg.islower()) #判断是否全部是小写False

#判断字符串是否有字母和数字组成

# msg='abc123'# print(msg.isalnum())# True

#判断字符串是否由纯字母组成

# msg='abcdef'# print(msg.isalpha())# True

列表类型

列表是可变类型

#优先掌握的操作

#按索引存取值（正存取和反存取），即可存也可取

name_list=['dzm','alex','egon',4,5]# print(name_list[1])# alex# print(name_list[-1])# 5#修改# name_list[0]='oldboy'# print(name_list)# # ['oldboy', 'alex', 'egon', 4, 5]print(input_cmd[-2], input_cmd[-1])  #取最后两个数据

#切片，顾头不顾尾，步长

name_list=['dzm','alex','egon',4,5]# print(name_list[0:2])# ['dzm', 'alex']# print(name_list[0::2])# ['dzm', 'egon', 5]

使用切片赋值还可在不替换原有元素的情况下插入新元素

numbers = [1, 5]numbers[1:1] = [2, 3, 4]numbers[1, 2, 3, 4, 5]这里我“替换”了一个空切片，相当于插入了一个序列

清空

lst = [1, 2, 3]lst.clear()lst[]

#长度,显示列表中有几个元素

name_list=['dzm','alex','egon',4,5]print(len(name_list)) 5

#成员运算 in 和 not in
#判断某个元素是否在列表中

# name_list=['dzm','alex','egon',4,5]# print('dzm' in name_list)# True# print(5 in name_list)# True

#追加
#append 默认加到最后面

# name_list=['dzm','alex','egon',4,5]# name_list.append('oldboy')# print(name_list)# ['dzm', 'alex', 'egon', 4, 5, 'oldboy']

#删除

#del是一种通用的删除方法，并非列表专用name_list=['dzm','alex','egon',4,5]del name_list[0]print(name_list)['alex', 'egon', 4, 5]

#remove 直接指定元素进行删除，是单纯的删除name_list.remove('dzm')print(name_list)['alex', 'egon', 4, 5]

pop 按照索引从列表中取走元素，等于是剪切，默认取走最后一个

name_list=['dzm','alex','egon',4,5]name_list.pop()print(name_list)['dzm', 'alex', 'egon', 4]name_list.pop(1)print(name_list)['dzm', 'egon', 4, 5]

赋值，将列表索引为1的元素赋值给一个新变量

res=name_list.pop(1)print(res)alex

#常用操作

#insert 按照索引位置去插入值

name_list=['dzm','alex','egon',4,5]name_list.insert(1,'oldboy')print(name_list)['dzm', 'oldboy', 'alex', 'egon', 4, 5]

#extend 加多个值

name_list=['dzm','alex','egon',4,5]name_list.extend([6,7,8])print(name_list)['dzm', 'alex', 'egon', 4, 5, 6, 7, 8]

#count 统计指定元素的个数

name_list=['dzm','alex','egon',4,5,'dzm']print(name_list.count('dzm'))2

#了解的内容

#copy 拷贝一个新列表

name_list=['dzm','alex','egon',4,5]l=name_list.copy()print(l)['dzm', 'alex', 'egon', 4, 5]

下面这样复制列表只是将另一个名称关联到列表而已，copy才是指向不同的列表
a = [1, 2, 3]
b = a

#reverse 反转

name_list=['dzm','alex','egon',4,5]name_list.reverse()print(name_list)[5, 4, 'egon', 'alex', 'dzm']

#sort排序，默认从小到大

list=[2,4,3,1]# list.sort()# print(list)# [1, 2, 3, 4]#从大到小# list.sort(reverse=True)# print(list)# [4, 3, 2, 1]

sort修改不返回任何值

元组类型

#存多个值，有序，不可变，主要用来读

#优先掌握的操作
#按索引取值，只能取

#切片 顾头不顾尾，步长

ages=(1,2,3,4)# print(ages[0:2])# (1, 2)

#长度

ages=(1,2,3,4)print(len(ages))4

#成员运算 in 和 not in

ages=('dzm',1,2,3,4)print('dzm' in ages)True

#其它操作

#index

ages=('dzm',66,77,88,99)print(ages.index(77))2

#count

ages=('dzm',66,77,88,99)print(ages.count('dzm'))2

字典类型

作用：存多个值,key-value存取，取值速度快
定义：key必须是不可变类型，value可以是任意类型
info={'name':'egon','age':18,'sex':'male'} #本质info=dict({....})
或
info=dict(name='egon',age=18,sex='male')

优先掌握的操作

1、按key存取值：可存可取
按key取值

info={'name':'dzm','age':18,'sex':'male'}print(input('name'))name

存值

info['hobbies']=['read','music']print(info){'name': 'dzm', 'age': 18, 'sex': 'male', 'hobbies': ['read', 'music']}

2、长度len
统计key的数量

info={'name':'dzm','age':18,'sex':'male'}print(len(info))3

3、成员运算in和not in

info={'name':'dzm','age':18,'sex':'male'}print('name' in info)Trueprint(666 not in info)True

需要掌握的字典的内置方法
4、删除
pop 将字典中key所对应的值从字典中取出来

info={'name':'dzm','age':18,'sex':'male'}print(info.pop('name'))print(info)dzm{'age': 18, 'sex': 'male'}

指定默认值
pop所指定的key如果不存在怎会报错，这时可以指定默认值(一般用None)得方式避免报错

print(info.pop('name123','没有这个key'))没有这个key

5、键keys()，值values()，键值对items()
info={'name':'dzm','age':18,'sex':'male'}
keys只取字典中的key

print(info.keys())dict_keys(['name', 'age', 'sex'])

values只取字典中的values

print(info.values())dict_values(['dzm', 18, 'male'])

可迭代类型，并不是列表类型
以上两种取值方法取出来的值可以在for循环中使用，for i in info.values()
举例

for key in info.keys():    print(key)nameagesex

items 将字典里的每对键值以元祖的形式取出来

print(info.items())dict_items([('name', 'dzm'), ('age', 18), ('sex', 'male')])

几种用法举例
第一种

for i in info.items():    print(i)('name', 'dzm')('age', 18)('sex', 'male')

第二种

for i in info.items():    print(i[0],i[1])name dzmage 18sex male

第三种

info={'name':'dzm','age':18,'sex':'male'}for k,v in info.items():    print(k,v)name dzmage 18sex male

需要掌握的方法

info={'name':'dzm','age':18,'sex':'male'}
get 取值
传统取值方式
print(info['name'])
get 取值方式如果没有这个key也不会报错，默认返货None，可以设置默认返回值

print(info.get('name'))dzm

如果没有这个key也不会报错，默认返货None，可以设置默认返回值

print(info.get('name123',123),)123

setdefault
如果字典中已经存在这个key了，则不修改
示例1

info={'name':'dzm','age':18,'sex':'male'}print(info.setdefault('age',19))18 #返回值为原字典中的值

有则不改，返回已有的值，没有则新增，返回新增的值
示例2

print(info.setdefault('hobbles',[]))print(info)[]{'name': 'dzm', 'age': 18, 'sex': 'male', 'hobbles': []}

示例3

info.setdefault('hobbles',[]).append('music')print(info){'name': 'dzm', 'age': 18, 'sex': 'male', 'hobbles': ['music']}

了解

clear
x和y最初都指向同一个字典，clear可以删除原来字典的所有元素，下面的例子中y也受到了影响，这和给x赋个空字典（x = {}）不同

x = {}y = xx['key'] = 'value'y{'key': 'value'}x.clear()y{}

info.popitem()
popitem 直接删除并去除一对键值对，pop只会去除key

info={'name':'dzm','age':18,'sex':'male'}print(info.popitem())('sex', 'male')

update 更新

info={'name':'dzm','age':18,'sex':'male'}info_new={'a':1,'age':19}语法：原字典.update(用于更新的字典)info.update(info_new)print(info){'name': 'dzm', 'age': 19, 'sex': 'male', 'a': 1}

通过上面的例子可以看出如果原字典没有这个key则将新的key和值加入到原来字典中
如果之前就有这个key，那么就更新这个key对应的value

.fromkeys() 创建一个空字典,并设置默认值
用法

dic={}.fromkeys(['name','age','sex'],None)print(dic){'name': None, 'age': None, 'sex': None}

集合

作用：去重，关系运算，

定义集合:
集合：可以包含多个元素，用逗号分割，
集合的元素遵循三个原则：
1：每个元素必须是不可变类型(可hash，可作为字典的key)
2: 没有重复的元素
3：无序

注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
自动去重

s={1,2,3,4,5,6,1,1,1}print(s){1, 2, 3, 4, 5, 6}

# 优先掌握的操作：
1、长度len

s={1,2,3,4,5,6,1,1,1}print(len(s))6

2、成员运算in和not in

print(1 in s)True

3、|合集,并集(将两个集合合并，且去重)

s1={1,2,3,4}s2={4,5,6}s3=s1 | s2print(s3){1, 2, 3, 4, 5, 6}

4、&交集（取两个集合共有的值）

s1={1,2,3,4}s2={4,5,6}print(s1 & s2){4}

5、-差集(前者减去与后者共有的部分)

s1={1,2,3,4}s2={4,5,6}print(s1 - s2){1, 2, 3}

6、^对称差集（取两个集合共有部分之外的部分，合为一个集合）

s1={1,2,3,4}s2={4,5,6}print(s1 ^ s2){1, 2, 3, 5, 6}

7、==(判断值相不相等)

8、父集：>,>=（判断的是包含关系）

s1={1,2,3,4}s2={3,4}print(s1 > s2)True

s1是s2的父集，s2是s1的子集

print(s1 >= s2)True

9、子集：<,<=(跟上面相同)

#常用操作
#pop (随机删，并返回删除的值，类似剪切)

# s1={1,2,3,'a',4}# print(s1.pop())# 1

#remove 指定元素删除，无返回值，单纯删除
#如果删除的元素不存在则报错

# s1={1,2,3,'a',4}# s1.remove('a')# print(s1)# {1, 2, 3, 4}

#discard，删除，但没有返回值
#删除不存在的值不会报错，这是它与remove的区别

# s1={1,2,3,'a',4}# s1.discard('a')# print(s1)# {1, 2, 3, 4}

#add 添加内容，无序

# s1={1,2,3,'a',4}# s1.add('b')# print(s1)# {1, 2, 3, 4, 'a', 'b'}

#isdisjoint如果两个集合没有交集则返回Ture

# s1={1,2,3,4}# s2={5,6}# print(s1.isdisjoint(s2))# True

文件处理

#默认是rt t就是text文本

# f=open('1.txt',encoding='utf-8') #打开文件# data=f.read() #发信号让操作系统读取文件

# print(data)# f.close()#文件关闭，回收操作系统资源

#执行后
#你好啊
#open打开.txt文件后会报错，windows默认使用gbk打开文件，而文件是使用utf-8存储的

#下面的语句等于f=open('1.txt',encoding='utf-8')
#在操作结束后会自动关闭文件，不用再收入f.close()

# with open('1.txt',encoding='utf-8') as f:#     pass

#文件打开后光标会自动在第一个字符前
#data=f.read()#读取全部内容，光标从头移动到了尾部

# f=open('1.txt',encoding='utf-8')# data1=f.read()# print('----1',data1)# data2=f.read()# print('----2',data2)# 结果：# ----1 你好啊# ----2

#读操作 只读模式，默认是文本读
#readline读取一行

# f=open('1.txt',encoding='utf-8')# print(f.readline())# print(f.readline())# print(f.readline())#结果# aaaa## bbbbb## cccc

#会发现多出了一行空行，这是print自带的换行功能

#使用end=''参数取消print的换行功能

# print(f.readline(),end='')# print(f.readline(),end='')# print(f.readline(),end='')#结果# aaaa# bbbbb# cccc

#readlines把文件每一行都读取出来放到一个列表里去

# f=open('1.txt',encoding='utf-8')# print(f.readlines())# ['aaaa\n', 'bbbbb\n', 'cccc\n']

#写操作 只写模式，默认是文本写
#如果文件不存在则创建，存在则覆盖
#文本方式打开只能往里面写字符，不能写数字

#write 写内容，需要自己写换行符

# f=open('1.txt','w',encoding='utf-8')# f.write('aaa\n')# f.write('bbb\n')# 或者# f.write('aaa\nbbb\nccc')

#writelines
#以列表格式存入文本

# f.writelines(['你好\n','你好啊'])# f.close()