运维八一
lyndon
2023-06-07
目录

数据类型

数据是用来表示状态的，不同的状态用不同的数据类型去表示

  • type（数据） 查看数据类型
  • id （数据） 查看内存地址

# 1. 数字（int、float、complex）

作用：年纪、等级、薪资、×××号、qq号等数字相关的

# 1.1 int-整型数字

age=10 #age=int(10)
print(type(age))

输出：<class 'int'>
1
2
3
4

在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647

在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

# 1.2 long-长整型数字

跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。

注意：

  1. 自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整 数数据后面不加字母L也不会导致严重后果了
  2. 在Python3里不再有long类型了，全都是int

# 1.3 float-浮点数

salary=3000.3 #salary=float(3000.3)
print(type(salary))

输出：<class 'float'>
1
2
3
4

# 1.4 复数-实部和虚部

x=1-2j
print(x.real)          #real查看实部
print(x.imag)          #imag查看虚部输出：

输出：
1.0
-2.0
1
2
3
4
5
6
7

# 1.5 进制转换

age=10 #age=int(10)
print(bin(age)) #10->2十进制转二进制
#1010  1*(2**3)+1*2=10
print(oct(age)) #10->8 十进制转八进制
print(hex(age)) #10->16 十进制转十六进制

输出：
0b1010
0o12
0xa
1
2
3
4
5
6
7
8
9
10

# 2. 字符串

作用：名字、性别、国籍、地址等描述信息

定义：在单引号/双引号/三引号，由一串字符组成

在python中，加了引号的字符都被认为是字符串（引号：单引号、双引号、三引号都可以），字符串也可以进行数学运算，但只有相加或相乘，而且字符串的拼接只能是双方都是字符串，不能跟数字或其它类型拼接

常用操作：

# 2.1 移除空白strip

name=input('username: ').strip()
print(name)

或
name=input('username: ')
print(name.strip())
1
2
3
4
5
6

也可以移除其他特殊字符

name='***egon********'
print(name.strip('*'))
print(name.lstrip('*'))    #移除左边的特殊字符
print(name.rstrip('*'))    #移除右边的特殊字符
1
2
3
4

# 2.2 切分split

user_info='root:x:0:0::/root:/bin/bash'
print(user_info.split(':')[5])        #指定：为分隔符，取第6段
1
2

也可以指定切割次数

cmd_info='get|a.txt|333333333'        #取get这个字符串
print(cmd_info.split('|')[0])
print(cmd_info.split('|',1)[0]        #指定切割1次
1
2
3

# 2.3 长度len

计算字符串的长度

name='egon'
# print(name.__len__())
print(len(name))       #name.__len__()
1
2
3

# 2.4 切片

name='hello world'
print(name[1])
print(name[2])
print(name[3])
print(name[1:7:2])            #含头不含尾，取第2-6个字符，指定步长为2
1
2
3
4
5

# 2.5 其他方法

  • startswith() 以括号里的内容开头
  • endswith() 以括号里的内容结尾
name='ab_cd'
print(name.endswith('cd'))
print(name.startswith('ab'))

输出：（布尔值）
True
True
1
2
3
4
5
6
7
  • replace(老的值，新的值，替换次数) 替换
name='tom say :i have one tesla,my name is tom'
print(name.replace('tom','john',1))
输出：
john say：i have one tesla,my name is alex
1
2
3
4
  • format的三种方法
print('{} {} {}'.format('egon',18,'male'))
print('{0} {1} {0}'.format('egon',18,'male'))
print('NAME:{name} AGE:{age} SEX:{sex}'.format(age=18,sex='male',name='egon'))
1
2
3
  • sdigit() 判断是否为数字
num='123'
print(num.isdigit())
输出：（返回布尔值）
True
1
2
3
4

判断输入内容是否为数字

oldboy_age=73
while True:
    age=input('>>: ').strip()                 #移除空格
    if len(age) == 0:continue
    if age.isdigit():
        age=int(age)
        print(age,type(age))
1
2
3
4
5
6
7

  • find() 查找字符所在的位置（下标），如果未找到字符不报错

  • index() 查找字符所在的位置（下标），如果未找到字符会报错

  • count() 统计查找的字符有多少个，默认是从左往右查找

  • rfind()、rindex() 从右往左查找

name='egon hello'
print(name.find('o'))
print(name.find('x'))
print(name.find('o',3,6))      #在第4到第6个之间查找字符

print(name.index('o'))
print(name.index('x'))
print(name.count('o',1,3))     #顾头不顾尾，如果不指定范围会查找所有
1
2
3
4
5
6
7
8
  • join() 更改分隔符
l=['egon','say','hello','world'] #类别内容必须都是字符串
print(':'.join(l))
输出：
egon:say:hello:world
1
2
3
4
  • center() 字符居中
  • ljust() 字符左对齐
  • rjust() 字符右对齐
  • zfill() 字符右对齐（默认填充字符为0）
name='egon'
print(name.center(30,'*'))     #指定宽度30，填充字符为*
print(name.ljust(30,'*'))
print(name.rjust(30,'*'))
print(name.zfill(30))          #填充字符为0输出：
*************egon*************
egon**************************
**************************egon
00000000000000000000000000egon
1
2
3
4
5
6
7
8
9
  • expandtabs() 指定tab键的空格数量
name='egon\thello'
print(name)
print(name.expandtabs(1))
1
2
3

  • lower() 字符全变为小写字符

  • upper() 字符全变为大写字符

name='EGON'
print(name.lower())
name='eg'
print(name.upper())
1
2
3
4

  • capitalize() 首字母大写

  • swapcase() 大小写翻转

  • title() 每个单词的首字母大写

name='egon say'
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='egon say hi'
print(msg.title()) #每个单词的首字母大写
1
2
3
4
5

  • isalnum() 判断字符串由数字和字母组成

  • isalpha() 判断字符串只由字母组成

name='egon123'
print(name.isalnum()) #字符串由字母和数字组成
name='egon'
print(name.isalpha()) #字符串只由字母组成

输出：（返回布尔值）
True
True
1
2
3
4
5
6
7
8
  • 判断数字类型
num1=b'4' #Bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

# isdigit能判断bytes,unicode，最常用的
print(num1.isdigit())
print(num2.isdigit())
print(num3.isdigit())
print(num4.isdigit())
# isdecimal能判断unicode
print(num2.isdecimal())
print(num3.isdecimal())
print(num4.isdecimal())
# isnumberic能判断unicode,汉字，罗马
print(num2.isnumeric())
print(num3.isnumeric())
print(num4.isnumeric())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 3. 布尔值（bool）

主要用做逻辑判断，只有两个值：

  • True(真)
  • False(假)
判断布尔值
>>>True or Flase and Flase
True
1
2
3

# 4. 列表

定义：[]内可以有多个任意类型的值，使用，分割

my_girl_friends=list(['alex','wupeiqi','yuanhao',4,10,30])
可以简写为：
my_girl_friends=['alex','wupeiqi','yuanhao',4,10,30]
1
2
3

可以存放多个值，每个值可以对应任意一种数据类型

names=[‘alex’,’egon’,’lyndon’]
1

要取列表内的元素，需要通过下标，从0开始

# 4.1 索引（根据下标取）

my_girl_friends=['alex','wupeiqi','yuanhao',4,10,30]
print(my_girl_friends[2])
1
2

# 4.2 切片

my_girl_friends=['alex','wupeiqi','yuanhao',4,10,30]
print(my_girl_friends[1:3])
1
2

# 4.3 追加

my_girl_friends=['alex','wupeiqi','yuanhao',4,10,30]
my_girl_friends.append('oldboy')
1
2

# 4.4 删除

  • pop() 未指定索引的话，从最后开始删除

  • remove() 按照值删除

my_girl_friends=['alex','wupeiqi','yuanhao',4,10,30]
my_girl_friends.pop()          #删除最后一个
my_girl_friends.pop(0)         #指定索引，删除第一个
my_girl_friends.remove('yuanhao')     #删除yuanhao
1
2
3
4

# 4.5 统计长度（统计的是列表内元素的个数）

my_girl_friends=['alex','wupeiqi','yuanhao',4,10,30]
my_girl_friends.__len__()
print(len(my_girl_friends))
1
2
3

# 4.6 in成员运算

my_girl_friends=['alex','wupeiqi','yuanhao',4,10,30]
print('wupeiqi' in my_girl_friends) 
输出：（返回布尔值）
True
1
2
3
4

# 4.7 插入

  • insert() 插入到指定位置之前
my_girl_friends=['alex','wupeiqi','alex','yuanhao',4,10,30]
my_girl_friends.insert(1,'Sb')
1
2

# 4.8 其他操作

clear()       清除列表内容
copy()        复制列表内容到新的列表
count()       统计列表内元素的个数
extend()      一次添加多个元素
index()       查看元素下标
reverse()     翻转列表
sort()        从小到大排序
1
2
3
4
5
6
7

队列：先进先出

  • 方法一：使用append追加，使用pop从第一个开始取
fifo=[]
#入队
fifo.append('first')
fifo.append('second')
fifo.append('third')
print(fifo)
#出队
print(fifo.pop(0))
print(fifo.pop(0))
print(fifo.pop(0))
1
2
3
4
5
6
7
8
9
10
  • 方法二：使用insert插入元素到第一，这样后插入的元素就排在前面，然后使用pop默认从最后一个开始取
#入队
# fifo.insert(0,'first')
# fifo.insert(0,'second')
# fifo.insert(0,'third')
# print(fifo)
#
# #出队
# print(fifo.pop())
# print(fifo.pop())
# print(fifo.pop())
1
2
3
4
5
6
7
8
9
10

堆栈：先进后出，后进先出

l=[]
#入栈
l.append('first')
l.append('second')
l.append('third')
#出栈
print(l)
print(l.pop())
print(l.pop())
print(l.pop())
1
2
3
4
5
6
7
8
9
10

# 5. 字典

作用：存多个值，key-value存取，取值速度快，字典内的键值对是无序的，不能使用下标取值

定义：key必须是不可改变类型，也成为可hash类型，value可以是任意类型，不可变的数据类型都可以当做字典的key

info={'name':'egon','age':18,'sex':'male'}  #本质info=dict({'name':'egon','age':18,'sex':'male'})
1

采用key:value的方式存储值，可以存放多个值，字典通过key来取value

dic={‘name’:’egon’,’passwd’:123}
1

可变数据类型定义（或称为不可hash数据类型）：

  • id不变
  • type不变
  • 值变了

列表属于可变类型，数字和字符串都是不可变类型

# 5.1 存/取

info={'name':'egon','age':18,'sex':'male'}
print(info['age'])     #取出key为age的value值
print（info.get(‘age’)）     #根据key取value值，如果不存在不会报错
info['height']=1.80    #存入一个key=height,value=1.80的元素
1
2
3
4

# 5.2 删除

pop(key,none) 按照key删除,如果key不存在，则显示none，不会抛出异常

info={'name':'egon','age':18,'sex':'male'}
print(info.pop('name'))
print(info.pop('asdfsadfasdfasfasdfasdfasdf',None))
1
2
3

# 5.3 其他方法

  • popitem() 会随机的删除字典中的一个键值对

  • keys() 会取出字典中所有的key

  • values() 会取出字典中所有的value

  • items() 会把字典以一个列表的形式打印出来，字典中的元素以列表中的元组表示

  • copy() 复制到一个新字典

  • clear() 清空字典

info={'name':'egon','age':18,'sex':'male'}
print(info.popitem())         #随机删除字典中的一个键值对
print(info.keys())            #取出字典中所有的key
print(info.values())          #取出字典中所有value
print(info.items())
for key,value in info.items(): # key,value=('name','egon')    
    print(key,value)
1
2
3
4
5
6
7
  • fromkeys(keys,value) keys用列表的形式，列表内为多个key，一个value对应多个key
info={'name':'egon','age':18,'sex':'male'}
dic=info.fromkeys(['name','age','sex'],11111111)
输出：
{'name': 11111111, 'age': 11111111, 'sex': 11111111}

老字典.update(新字典)   # 用新的字典更新老的字典
1
2
3
4
5
6
  • setdefault() 一个key使用列表的方式储存多个vaule值
d={}
d.setdefault('hobby',[]).append('play1') #d['hobby']
d.setdefault('hobby',[]).append('play2') #d['hobby']
d.setdefault('hobby',[]).append('play3') #d['hobby']
print(d)

输出：
{'hobby': ['play1', 'play2', 'play3']}
1
2
3
4
5
6
7
8

# 6. 元组

作用：存多个值，相当于一个元素不可改变的列表，主要用于读

定义：使用()进行定义，可以当做字典的key

# 6.1 索引

index() 根据下标取值

age=(11,22,33,44,55,33)# 本质age=tuple((11,22,33,44,55))
print(age.index(33))
1
2

# 6.2 长度

len() 计算长度

count() 统计元素的个数

age=(11,22,33,44,55,33)
print(len(age))
print(age.count(33))
1
2
3

# 6.3 切片

age=(11,22,33,44,55,33)
print(age[1:4])
1
2

# 6.4 练习：简单购物车

打印商品信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入

msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
goods_l=[]

while True:
    for key in msg_dic:
        # print('Goods Name:%s Price:%s' %(key,msg_dic[key]))
        print('\033[43mName:{name} Price:{price}\033[0m'.format(price=msg_dic[key],name=key))
    choice=input('your goods name>>: ').strip()
    if len(choice) == 0 or choice not in msg_dic:continue
    count=input('your count>>: ').strip()
    if count.isdigit():
        goods_l.append((choice,msg_dic[choice],int(count)))
    print(goods_l)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 7. 集合

作用：去重，关系运算

定义：由不同元素组成的集合，集合中是一组无序排列的可hash值（也就是集合内的值都是不可变数据类型），集合内的元素唯一，可以作为字典的key，集合的目的是将不同的值存放在一起，不同的集合之间用来做关系运算，无需纠结于集合的单个值

# 7.1 成员运算

in 和 not in，结果返回布尔值

# 7.2 关系运算

  • & 交集

  • | 并集

  • - 差集

  • ^ 对称差集

  • >= 父集

  • <= 子集

父集、子集会返回布尔值

# 关系运算
s1={1,10,11,22}
s2={1,11,33}
# 交集
print(s1 & s2)
# 并集
print(s1 | s2)
# 差集
print(s1 - s2)print(s2 - s1)
# 对称差集
print(s1 ^ s2)
# 父集
s1={1,2,3,4}s2={1,5}print(s1 >= s2)
# 子集
print(s1 <= s2)print(s2 <= s1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 7.3 增/删

  • add() 增加元素（必须是不可变类型）

  • pop() 删除元素（随机删）

  • remove() 删除元素（指定元素名，元素不存在会报错）

  • discard() 删除元素（指定元素名，元素不存在不会报错）

# 7.4 方法

使用方法来表示各种集合

  • intersection 交集

  • union 并集

  • difference 差集

  • symmetric_difference 对称差集

# 8. 总结

# 按存值个数区分

  • 标量／原子类型：数字，字符串
  • 容器类型：列表，元组，字典

# 按可变不可变区分

  • 可变：列表，字典
  • 不可变：数字，字符串，元组

# 按访问方式区分

  • 直接访问：数字
  • 按照索引访问（序列类型）：字符串，列表，元组
  • key访问（映射类型）：字典
上次更新: 2023/06/08, 10:26:48
格式化输出和运算符
流程控制

← 流程控制→

最近更新
01
ctr和crictl显示镜像不一致
03-13
02
alpine镜像集成常用数据库客户端
03-13
03
create-cluster
02-26
更多文章>
Theme by Vdoing | Copyright © 2015-2024 op81.com
苏ICP备18041258号-2