Python打印数据类型 python打印int型数据

转载

mob6454cc76dff7 2023-09-26 10:55:36

文章标签 Python打印数据类型 python 字符串 Python bc 文章分类 Python 后端开发

Python-基本数据类型的常用内置方法

一、数字类型

int类型

定义：

age = 20  # 本质为 age = int(20)

# 注意：名字+括号的意思就是调用某个功能，比如
# print(...)调用打印功能
# int(...)调用创建整型数据的功能
# float(...)调用创建浮点型数据的功能

类型转换：

（1）纯数字的字符串转成int

# 纯数字的字符串转成int
res = int('100111')
print(res, type(res))  # 100111 <class 'int'>

（2）十进制转成其他进制

# 十进制 -> 二进制
11 - > 1011
1011-> 8 + 2 + 1
print(bin(11))  # 0b1011  0b表示二进制

# 十进制 -> 八进制
print(oct(11))  # 0o13  0o表示八进制

# 十进制 -> 十六进制
print(hex(11))  # 0xb  0x表示十六进制
print(hex(123))  # 0x7b

（3）其他进制转十进制

# 二进制 -> 十进制
print(int('0b1011',2))  # 11

# 二进制 -> 八进制
print(int('0o13',8))  # 11

# 二进制 -> 十六进制
print(int('0xb',16))  # 11

float类型

定义：

salary = 333.3  # 本质salary = float(333.3)

类型转换：

res = float("3.1")
print(res, type(res))  # 3.1 <class 'float'>

int与float没有需要掌握的内置方法，它们的使用就是数学运算和比较运算。

二、字符串类型（重要）

定义：

msg = 'hello python'  # msg = str('msg')

类型转换：str可以把任意其他类型都转成字符串

res = str({'a': 1})
print(res, type(res))  # {'a': 1} <class 'str'>

内置方法：Python的字符串是不可变类型，所以通过内置方法得到的字符串并不是改变了原字符串，而是产生了新的字符串。

1. 按索引取值(正向取+反向取) ：只能取不能改

msg = 'hello world'
# 正向取
print(msg[0])  # h
print(msg[5])  # 空格
# 反向取
print(msg[-1])  # d

# 字符串按索引只能取值，若进行赋值操作则会报错
msg[0] = 'H'  # 程序报错

2. 切片：索引的拓展应用，从一个大字符串中拷贝出一个子字符串

msg = 'hello world'
# 要取到索引为4的字符结束的字符串，范围必须写到5
# 程序是“顾头(0)不顾尾(5)”
res = msg[0:5]
print(res)  # hello
print(msg)  # hello world

# 步长

res = msg[0:5:2]  # 0 2 4
print(res)  # hlo

# 反向步长

res = msg[5:0:-1]
print(res)  # " olle"

print(msg[0:5:-1])  # 空
# 0:5的意思为从左往右，-1是从右往左
# 相当于要求人要往前走，但腿必须往后迈，是一件相悖的事情，所以结果为空。

print(msg[5:0])  # 空
# 步长不写默认为1，程序相当于print(msg[5:0:1]),与上面是一个道理，所以结果为空。要想正常输出，步长也应该更改为-1。

# 反转字符串

msg = 'hello world'
res = msg[::-1]
print(res)  # dlrow olleh

# 步长为正，从左至右。头位不写默认0，尾位不写默认为全；
# 步长为负，从右至左。头位不写默认为全，尾位不写默认为全。

msg = 'hello world'

res0 = msg[:5]
print(res0)  # hello

res1 = msg[0:]
print(res1)  # hello world

res2 = msg[:5:-1]
print(res2)  # dlrow

res3 = msg[4::-1]
print(res3)  # olleh

# 步长为负，尾位写0时，取不到0号字符。“顾头不顾尾”
res4 = msg[4:0:-1]
print(res4)  # olle

# 字符串是不可变类型，通过内置方法得到的字符串并不是改变了原字符串，而是产生了新的字符串，那这里的id为什么还是一样的？

msg1 = 'hello:world:<>:19[]==123'
msg2 = msg1[:]
print(msg1, id(msg1))
# hello:world:<>:19[]==123 1271272885104
print(msg2, id(msg2))
# hello:world:<>:19[]==123 1271272885104

# 通过[:]的方法，等于是拷贝了整个字符串。
# 取字符串是为了读(因为不能改)，没有必要生成和原字符串一模一样的新字符串，所以[:]得到的字符串并不是新生成的，还是原来的字符串。

3. 长度len

# 统计字符个数

msg = 'hello world'
print(len(msg))  # 11

4. 成员运算in和not in

# 判断一个子字符串是否存在于一个大字符串中

print("hello" in "hello world")  # True
print("hello" not in "hello world")  # False 推荐使用
print(not "hello" in "hello world")  # False 不推荐使用

5. 移除字符串左右两侧的符号strip

# 默认去掉的是空格

msg = '      abcd      '
res = msg.strip()
print(msg) # 不会改变原值  “      abcd      ”
print(res) # 是产生了新值  “abcd”

# 想去掉什么符号，在strip()中写入这个符号即可。

msg = '****abcd****'
print(msg.strip('*'))  # abcd

# strip只去两边，不去中间

msg = '****a*****bcd****'
print(msg.strip('*'))  # a*****bcd

# 去掉多种符号，在strip()中可以不按顺序的写入要去掉的符号即可。

msg = '**/*===-**abcd**---/-=()**'
print(msg.strip('*/-=()'))  # abcd

# 小例子：清除用户误触输入空格的影响

inp_user = input('your name>>: ').strip()
inp_pwd = input('your password>>: ').strip()
if inp_user == 'admin' and inp_pwd == '123':
    print('登录成功')
else:
    print('账号密码错误')

6. 切分split：把一个字符串按照某种分隔符进行切分，得到一个列表

# 默认分隔符是空格

info = 'Python JavaScript Golang'
res = info.split()
print(res)  # ['Python', 'JavaScript', 'Golang']

# 指定分隔符

info = 'Python、JavaScript、Golang'
res = info.split('、')
print(res)  # ['Python', 'JavaScript', 'Golang']

# 指定分隔次数

info = 'Python:JavaScript:Golang'
res = info.split(':', 1)  # 分隔1次
print(res)  # ['Python', 'JavaScript:Golang']

7. 循环

info = 'Python:JavaScript:Golang'
for x in info:
    print(x, end=',')

# P,y,t,h,o,n,:,J,a,v,a,S,c,r,i,p,t,:,G,o,l,a,n,g,

8. strip，lstrip，rstrip

msg = '***abcd****'
# 移除两侧符号 详细用法见上方5。
print(msg.strip('*'))  # abcd
# 移除左侧符号
print(msg.lstrip('*'))  # abcd****
# 移除右侧符号
print(msg.rstrip('*'))  # ***abcd

9. lower，upper

msg = 'AbbbCCCC'
print(msg.lower())  # abbbcccc 将字符串中的大写字母转成小写字母
print(msg.upper())  # ABBBCCCC 将字符串中的小写字母转成大写字母

10. startswith，endswith

print("alex is sb".startswith("alex"))  # True 判断字符串是否以指定字符(串)开头
print("alex is sb".endswith('sb'))  # True 判断字符串是否以指定字符(串)结尾

11. format

（1）按位置传值：

res = '我的名字是 {} 我的年龄是 {}'.format('JL',19)
print(res)
# 我的名字是 JL 我的年龄是 19

res='我的名字是 {0}{0}{0} 我的年龄是 {1}{1}'.format('JL',19)
print(res)
# 我的名字是 JLJLJL 我的年龄是 1919

（2）打破位置的限制，按照 key = value 传值：

res="我的名字是 {name} 我的年龄是 {age}".format(age=19,name='JL')
print(res)
# 我的名字是 JL 我的年龄是 19

12. split，rsplit：将字符串切成列表

split见上方“6.切分split”

info = "Python:JavaScript:Golang"
# split按照从左往右的顺序切分
print(info.split(':', 1))  # ['Python', 'JavaScript:Golang']
# rsplit按照从右往左的顺序切分
print(info.rsplit(':', 1))  # ['Python:JavaScript', 'Golang']

13. join：把列表拼接成字符串

l = ['Python', 'JavaScript', 'Golang']

res0 = l[0] + ":" + l[1] + ":" + l[2]
print(res0)  # Python:JavaScript:Golang

res = ":".join(l)  # 按照某个分隔符号，把元素全为字符串的列表拼接成一个大字符串
print(res)  # Python:JavaScript:Golang

l = [1, "2", 'aaa']
res = ":".join(l)  # 程序报错

14. replace

msg = "you can you up no can no bb"

# 三个参数，第一个参数为要被替换的字符串，第二个参数为要替换成的字符串，第三个参数为替换次数，不写为全部。
print(msg.replace("you", "YOU", ))  # YOU can YOU up no can no bb
print(msg.replace("you", "YOU", 1))  # YOU can you up no can no bb

15. isdigit

# 判断字符串是否由纯数字组成，带除数字之外的任何符号都不行

print('123'.isdigit())  # True
print('12.3'.isdigit())  # False

# 应用案例

age = input('请输入你的年龄：').strip()
if age.isdigit():
    age = int(age)  # int("abbab")
    if age > 19:
        print('猜大了')
    elif age < 19:
        print('猜小了')
    else:
        print('才最了')
else:
    print('必须输入数字，傻子')

16. find，rfind，index，rindex，count

# 找到返回起始索引

msg = 'hello world of python '

print(msg.find('e'))  # 1 返回要查找的字符串在大字符串中的起始索引
print(msg.find('py'))  # 15

# find与index的功能和用法一样，唯一区别在于找不到时的情况
print(msg.index('o'))  # 4
print(msg.index('of'))  # 12

# 找不到

msg = 'hello world of python '

print(msg.find('xxx'))  # 返回-1，代表找不到
print(msg.index('xxx'))  # 程序报错

# count统计子字符(串)在大字符串中出现的次数

msg = 'Hello python hahaha,Bye java oh my god!'
print(msg.count('a'))  # 5
print(msg.count('ha'))  # 3

17. center，ljust，rjust，zfill

# 两个参数，第一个参数为指定字符串长度，第二个参数为补全所用符号

print('jl'.center(12, '*'))  # *****jl*****  长度12，'jl'居中，其余位置用'*'补全。
print('jl'.ljust(15, '*'))  # jl*************  左对齐
print('jl'.rjust(10, '*'))  # ********jl  右对齐

# 一个参数，为指定字符串长度，其余位置用'0'补全，内容右对齐。
print('jl'.zfill(10))  # 00000000jl

18. expandtabs

# '\n'代表换行的意思，'\t'代表制表符(空格)的意思。
# expandtabs()用来设置制表符代表的空格数

msg = 'hello\tworld'
print(msg.expandtabs(2))  # 设置制表符代表的空格数为2

19. captalize，swapcase，title

# 三个方法都无参数
# capitalize()：首字母大写；
# swapcase()：大小写反转，大写全变小写，小写全变大写；
# title()：每个单词的首字母大写。

print("hello world jl".capitalize())  # Hello world jl
print("Hello WorLd JL".swapcase())  # hELLO wORlD jl
print("hello world jL".title())  # Hello World Jl

20. is数字系列

# 判断是否为数字，数字分四种。

num1 = b'4'  # bytes
num2 = u'4'  # unicode,python3中无需加u就是unicode
num3 = '四'  # 中文数字
num4 = 'Ⅳ'  # 罗马数字

# isdigit只能识别：num1、num2
print(num1.isdigit()) # True
print(num2.isdigit()) # True
print(num3.isdigit()) # False
print(num4.isdigit()) # False


# isnumberic可以识别：num2(普通数字)、num3(中文数字)、num4(阿拉伯数字)
print(num2.isnumeric()) # True
print(num3.isnumeric()) # True
print(num4.isnumeric()) # True

# isdecimal只能识别：num2
print(num2.isdecimal())  # True
print(num3.isdecimal())  # False
print(num4.isdecimal())  # False

21. is其他

print('abc'.islower())  # 判断是否全为小写。
print('ABC'.isupper())  # 判断是否全为大写。
print('Hello World'.istitle())  # 判断是否各单词首字母大写。
print('123123aadsf'.isalnum())  # 判断字符串是否只由字母或数字组成，纯字母/纯数字/字母+数字。
print('ad'.isalpha())  # 判断字符串是否只由字母组成。
print('     '.isspace())  # 判断字符串是否只由空格组成。
print('print'.isidentifier())  # 判断标识符是否合法，python内置的标识符全部为合法。
print('age_of_tony'.isidentifier())  # 字母数字下划线组成，且开头不是数字，合法。
print('1age_of_tony'.isidentifier())  # 数字开头，不合法。

三、列表类型（有序）

作用：按位置存放多个值

类型转换：但凡能够被for循环遍历的类型都可以当做参数传给list()转成列表

res = list('hello')
print(res)  # ['h', 'e', 'l', 'l', 'o']

res = list({'k1': 111, 'k2': 222, 'k3': 3333})
print(res)  # ['k1', 'k2', 'k3']

内置方法

按索引存取值(正向存取+反向存取)：即可以取也可以改

l = [111, 'world', 'hello']

# 正向取
print(l[0])  # 111
# 反向取
print(l[-1])  # hello

# 可以取也可以改：索引存在则修改对应的值
l[0] = 222
print(l)  # [222, 'world', 'hello']

# 无论是取值操作还是赋值操作：索引不存在则报错
l[3] = 333  # 程序报错

切片(顾头不顾尾，步长)

l = [111, 'world', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]

print(l[0:3])  # [111, 'world', 'hello']
print(l[0:5:2])  # 0 2 4 [111, 'hello', 'b']

print(l[0:len(l)])  # [111, 'world', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
print(l[:])  # [111, 'world', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]

new_l = l[:]  # 切片等同于拷贝行为，而且相当于浅copy
print(id(l))  # 2268740252288
print(id(new_l))  # 2268740082368
l[-1][0] = 1111111
print(l)  # [111, 'world', 'hello', 'a', 'b', 'c', 'd', [1111111, 2, 3]]
print(new_l)  # [111, 'world', 'hello', 'a', 'b', 'c', 'd', [1111111, 2, 3]]  可以看到new_l也发生了变化

# 列表反转倒序
print(l[::-1])  # [[1111111, 2, 3], 'd', 'c', 'b', 'a', 'hello', 'world', 111]

长度

print(len([1, 2, 3]))  # 3

成员运算in和not in

print('aaa' in ['aaa', 1, 2])  # True
print(1 in ['aaa', 1, 2])  # True
print(3 not in ['aaa', 1, 2])  # True

往列表中添加值

追加

l = [111, '222', 'hello']
l.append(3333)
print(l)  # [111, '222', 'hello', 3333]
l.append(4444)
print(l)  # [111, '222', 'hello', 3333, 4444]

指定位置插入值

l = [111, 'JavaScript', 'Golang']
l.insert(0, 'Python')  # (索引, 插入值)
print(l)  # ['Python', 111, 'JavaScript', 'Golang']
l.insert(0, 1)
print(l)  # [1, 'python', 111, 'JavaScript', 'Golang']

l.extend()

# 列表后面追加另一个列表的全部元素

new_l = [1, 2, 3]
l = [111, 'Python', 'JavaScript']
l.append(new_l)
print(l)  # [111, 'Python', 'JavaScript', [1, 2, 3]]  结果不对，插入的直接是整个列表

# 使用for循环可以实现

new_l = [1, 2, 3]
l = [111, 'Python', 'JavaScript']

for item in new_l:
    l.append(item)
print(l)  # [111, 'Python', 'JavaScript', 1, 2, 3]

# extend直接实现上述代码

l.extend(new_l)
print(l)  # [111, 'Python', 'JavaScript', 1, 2, 3]
l.extend('abc')
print(l)  # [111, 'Python', 'JavaScript', 1, 2, 3, 'a', 'b', 'c']

删除

方式一：通用的删除方法，只是单纯的删除、没有返回值

l = [111, 'world', 'hello']
del l[1]
# x = del l[1]  # 程序报错，不支持赋值语法(没有返回值)
print(l)  # [111, 'hello']

方式二：l.pop()根据索引删除，会返回删除的值

l = [111, 'world', 'hello']
l.pop()  # 不指定索引默认删除最后一个
l.pop()
print(l)  # [111]

l = [111, 'world', 'hello']
res = l.pop(1)
print(l)  # [111, 'hello']
print(res)  # world

方式三：l.remove()根据元素删除，返回None(主观上相当于无返回值)

l = [111, 'world', [1, 2, 3], 'hello']

l.remove([1, 2, 3])
print(l)  # [111, 'world', 'hello']

res = l.remove('world')
print(res)  # None
print(l)  # [111, 'hello']

循环

l = [1, 'aaa', 'bbb']
for x in l:
    print(x)
    
# 结果
# 1
# aaa
# bbb

l.copy

见“Python学习_ 基础 _05_if条件判断、列表的深浅copy：三、2. a. 浅copy”

l.count()

# 元素在列表中的出现次数

l = [1, 'aaa', 'bbb', 'aaa', 'aaa']
print(l.count('aaa'))  # 3

l.index()

# 查找指定元素在列表中第一次出现的位置，列表没有find()方法，只有index()方法。

l = [1, 'aaa', 'bbb', 'aaa', 'aaa']
print(l.index('aaa'))  # 1
print(l.index('aaaaaaaaa'))  # 找不到报错

l.clear()

# 清空列表中所有的元素

l = [1, 'aaa', 'bbb', 'aaa', 'aaa']
l.clear()  # 无参数
print(l)  # []

l.reverse()：不是排序，而是将列表倒过来(反转)

l = [1, 'PY', 'JS', 'GO']
l.reverse()  # 无参数
print(l)  # ['GO', 'JS', 'PY', 1]

l.sort(): 列表内元素必须是同种类型才可以排序，不然会报错

l = [11, -3, 9, 2, 3.1]
l.sort()  # 默认从小到大排，称之为升序  l.sort(reverse=False)
print(l)  # [-3, 2, 3.1, 9, 11]

l.sort(reverse=True)  # 从大到小排，设置为降序
print(l)  # [11, 9, 3.1, 2, -3]

l = ['c', 'e', 'a']
l.sort()
print(l)  # ['a', 'c', 'e']

字符串可以比大小，按照对应的位置的字符依次pk，直到比出胜负。

字符的大小是按照ASCI码表的先后顺序加以区别，表中排在后面的字符大于前面的。

print('a' > 'b')  # False
print('abz' > 'abcdefg')  # True

列表也可以比大小，原理同字符串一样依次pk，但是对应位置的元素必须是同种类型。

l1 = [1, 'abc', 'zaa']
l2 = [1, 'abc', 'zb']

print(l1 < l2)  # True

列表实现队列与堆栈

队列：FIFO(First In, First Out)，先进先出

l=[]
# 入队操作

l.append('first')
l.append('second')
l.append('third')

print(l)  # ['first', 'second', 'third']

# 出队操作

print(l.pop(0))  # first
print(l.pop(0))  # second
print(l.pop(0))  # third

堆栈：LIFO(Last In, First Out)，后进先出

l=[]
# 入栈操作

l.append('first')
l.append('second')
l.append('third')
print(l)  # ['first', 'second', 'third']

# 出栈操作

print(l.pop())  # third
print(l.pop())  # second
print(l.pop())  # first

四、元组类型(就是一个“不可变的列表”，有序，属于不可变类型)

作用：按照索引/位置存放多个值，只用于读不用于改

定义：（）内用逗号分隔开多个任意类型的元素j

t = (1, 1.3, 'aa')  # t=tuple((1,1.3,'aa'))
print(t, type(t))  # (1, 1.3, 'aa') <class 'tuple'>

t = (10,)  # 如果元组中只有一个元素，必须加逗号
print(t, type(t))  # (10,) <class 'tuple'>

x = (10)  # 单独一个括号代表包含的意思
print(x, type(x))  # 10 <class 'int'>

# 元组的元素不能被更改，没有更改操作。
# 从本质上讲，是元组内元素的内存地址不能发生变化。若元组内有元素是可变类型，值发生变化内存而地址不发生变化，这种情况可以更改。

t = (1, 1.3, 'aa')  # t=(0->值1的内存地址,1->值1.3的内存地址,2->值'aaa'的内存地址，)
# t[0] = 11111  程序报错

t = (1, [11, 22])  # t=(0->值1的内存地址,1->值[11,22]的内存地址，)
print(id(t[0]), id(t[1]))  # 140711415256736 1630339462720

# t[0] = 111111111 # 不能改
# t[1] = 222222222 # 不能改

t[1][0] = 11111111111111111
print(t)  # (1, [11111111111111111, 22])
print(id(t[0]), id(t[1]))  # 140711415256736 1630339462720

类型转换：

# 使用tuple()进行转换，变为元组类型

print(tuple('hello'))  # ('h', 'e', 'l', 'l', 'o')
print(tuple([1, 2, 3]))  # (1, 2, 3)
print(tuple({'a1': 111, 'a2': 333}))  # ('a1', 'a2')

内置方法：

按索引取值（正向取+反向取）：只能取

t = ('aa', 'bbb', 'cc')
print(t[0])  # aa
print(t[-1])  # cc

切片（顾头不顾尾，步长）（切片是一种拷贝操作）

t = ('aa', 'bbb', 'cc', 'dd', 'eee')
print(t[0:3])  # ('aa', 'bbb', 'cc')
print(t[::-1])  # ('eee', 'dd', 'cc', 'bbb', 'aa')

长度

t = ('aa', 'bbb', 'cc', 'dd', 'eee')
print(len(t))  # 5

成员运算in和not in

t = ('aa', 'bbb', 'cc', 'dd', 'eee')
print('aa' in t)  # True

循环

t = ('aa', 'bbb', 'cc', 'dd', 'eee')
for x in t:
    print(x)
# aa
# bbb
# cc
# dd
# eee

index()

t = (2, 3, 111, 111, 111, 111)
print(t.index(111))  # 2
#print(t.index(1111111111))  # 找不到，报错

count()

t = (2, 3, 111, 111, 111, 111)
print(t.count(111))  # 4

五、字典类型（无序）

定义：{ }内用逗号分隔开多个 key：value，其中 value 可以使任意类型，但是 key 必须是不可变类型，且不能重复。

造字典的方式一：

d = {'k1': 111, (1, 2, 3): 222}  # d=dict(...)
print(d['k1'])  # 111
print(d[(1, 2, 3)])  # 222
print(type(d))  # <class 'dict'>

d = {}  # 默认定义出来的是空字典
print(d, type(d))  # {} <class 'dict'>

造字典的方式二：

d = dict(x=1, y=2, z=3)
print(d, type(d))  # {'x': 1, 'y': 2, 'z': 3} <class 'dict'>

造字典的方式三：快速初始化一个字典

# 字典的key值分别对应列表元素，值全为None

keys=['name','age','gender']
# d={}
# for k in keys:
#     d[k]=None
# print(d)  # {'name': None, 'age': None, 'gender': None}
d={}.fromkeys(keys,None) # 一行代码搞定上述for循环的工作
print(d)  # {'name': None, 'age': None, 'gender': None}



# fromkeys()对字典进行初始化，不一定非是None，写其他不可变类型也是可以的。
# fromkeys()产生的是一个新的字典,必须要用一个变量名接住。
# 初始化值要用不可变类型，实际情况是所有的值都来自同一个地方，id都是相同的。对其中一个进行更改，直接改变绑定关系，所以影响不大。
# 切记不要用可变类型，如果用了，对其中一个进行更改，所有的值都会发生改变。

keys = ['a', 'b', 'c', 'd']
d = {}

d = d.fromkeys(keys, 10)
print(d, '\n', id(d['a']), id(d['b']), id(d['c']))
# {'a': 10, 'b': 10, 'c': 10, 'd': 10} 
#  140711063066560 140711063066560 140711063066560

d = d.fromkeys(keys, '字母')
print(d, '\n', id(d['a']), id(d['b']), id(d['c']))
# {'a': '字母', 'b': '字母', 'c': '字母', 'd': '字母'} 
#  2234263779728 2234263779728 2234263779728

d = d.fromkeys(keys, [1, 2, 3, 4])
d['a'][0] = 99
print(d)  # {'a': [99, 2, 3, 4], 'b': [99, 2, 3, 4], 'c': [99, 2, 3, 4], 'd': [99, 2, 3, 4]}

数据类型转换

info = [
    ['name', '李白'],
    ('age', 18),
    ['gender', 'male']
]

# 使用循环进行数据类型转换
d = {}
for x in info:
    d[x[0]] = x[1]  # x第一次取的是 ['name', '李白']
print(d)  # {'name': '李白', 'age': 18, 'gender': 'male'}

# 对上面的代码进行优化
d = {}
for k, v in info:  # 第一次为：k,v=['name','李白'] 循环相当于进行三次解压赋值
    d[k] = v
print(d)  # {'name': '李白', 'age': 18, 'gender': 'male'}

# dict()就相当于做了上面的事情
res = dict(info)  # 一行代码搞定上述for循环的工作
print(res)

内置方法

按key存取值：可存可取

d = {'k1': 111}

# 针对赋值操作：key存在，则修改
d['k1'] = 222

# 针对赋值操作：key不存在，则创建新值
d['k2'] = 3333

print(d)  # {'k1': 222, 'k2': 3333}

长度len

d = {'k1': 111, 'k2': 2222, 'k1': 3333, 'k1': 4444}
print(d)  # {'k1': 4444, 'k2': 2222}
print(len(d))  # 2

成员运算in和not in：根据key

d = {'k1': 111, 'k2': 2222}
print('k1' in d)  # True
print(111 in d)  # False

删除

4.1 通用删除

d = {'k1': 111, 'k2': 2222}
del d['k1']
print(d)  # {'k2': 2222}

4.2 pop删除：根据key删除元素，返回删除key对应的那个value值

d = {'k1': 111, 'k2': 2222}
res = d.pop('k2')
print(d)  # {'k1': 111}
print(res)  # 2222

4.3 popitem删除：随机删除(不是从末尾删除，因为字典无序)，返回元组(删除的key,删除的value)

d = {'k1': 111, 'k2': 2222}
res = d.popitem()
print(d)  # {'k1': 111}
print(res)  # ('k2', 2222)

键keys()，值values()，键值对items() =>在python3中得到的是老母鸡(为了节省空间)

'''
在python2中：
d.keys()得到的是一个由字典全部key组成的列表；
d.values()得到的是一个由字典全部key的值(value)组成的列表；
d.items()得到的是一个由字典(key,value)组成的一个个元组所组成的列表。

>>> d={'k1':111,'k2':2222}
>>> 
>>> d.keys()
['k2', 'k1']
>>> d.values()
[2222, 111]
>>> d.items()
[('k2', 2222), ('k1', 111)]
>>>
'''

# 在python3中：
d = {'k1': 111, 'k2': 2222}
print(d.keys())  # dict_keys(['k1', 'k2'])
print(d.values())  # dict_values([111, 2222])
print(d.items())  # dict_items([('k1', 111), ('k2', 2222)])

让老母鸡下蛋的方法看下面“6. for循环”

for循环

d = {'k1': 111, 'k2': 2222}

#for k in d.keys():
#    print(k)  # k1  k2
# 可以用d直接替代d.keys()

for k in d:
    print(k)  # k1  k2

for v in d.values():
    print(v)  # 111  2222
    
for item in d.items():
    print(item)  # ('k1', 111)  ('k2', 2222)  取出来的是元组

for k, v in d.items():  # 利用解压赋值
    print(k, v)  # k1 111  k2 2222

# 使用list()直接转换成列表
print(list(d.keys()))  # ['k1', 'k2']
print(list(d.values()))  # [111, 2222]
print(list(d.items()))  # [('k1', 111), ('k2', 2222)]

d.clear()（清空字典，结果为 { } ）

d.copy()（相当于浅拷贝）

d.update()

d = {'k1': 111, 'k2': 2222}
d.update({'k2': 222, 'k3': 333, 'k1': 88888})
print(d)  # {'k1': 88888, 'k2': 222, 'k3': 333}

d.get()：根据key取值，容错性好

d = {'k1': 111, 'k2': 2222}
# print(d['k3'])  # key不存在则报错

print(d.get('k1'))  # 111
print(d.get('k3'))  # key不存在不报错，而是返回None


# d.get()的自定义返回值用法

d = {'k1': 111, 'k2': 2222}
res0 = d.get('k1', '空空如也')
res1 = d.get('k3', '空空如也')
print(res0)  # 111   存在即返回对应value值
print(res1)  # 空空如也  不存在即返回自定义值

d.setdefault()：有则不改，无则添加

# 常规方法实现

info = {}
if 'name' in info:
    pass  # 什么都不执行(执行空语句)，也可以写成 ... ，效果等同于pass，但这个位置不能不写代码
else:
    info['name'] = 'Python'
print(info)  # {'name': 'Python'}

# 如果key已有则不添加（不更改），返回字典中key对应的值

info = {'name': 'JS'}
res = info.setdefault('name', 'PY')
print(res)  # JS
print(info)  # {'name': 'JS'}

# 如果key没有则添加，返回字典中key对应的值

info = {}
res = info.setdefault('name', 'GO')
print(res)  # GO
print(info)  # {'name': 'GO'}

六、集合类型

在学习集合类型之前，先思考一个简单的问题，怎样得到具有重合元素的两个列表的交集(重合)部分？且得到的部分用新列表表示。

# 用一个新的列表输出下面两个列表的重合部分

friends1 = ["zero", "kevin", "jason", "egon"]
friends2 = ["Jy", "ricky", "jason", "egon"]

l = []
for x in friends1:
    if x in friends2:
        l.append(x)
print(l)  # ['jason', 'egon']

定义：

定义集合的三大注意：
集合内元素必须为不可变类型
集合内元素无序
集合内元素没有重复

s = {1, 2}  # s=set({1,2})

# s = {1, [1, 2]}  # 程序报错  集合内元素必须为不可变类型
s = {1, 'a', 'z', 'b', 4, 7}  # 集合内元素无序
s = {1, 1, 1, 1, 1, 1, 'a', 'b'}  # 集合内元素没有重复
print(s)  # {1, 'a', 'b'}

s = {}  # 默认是空字典
print(type(s))  # <class 'dict'>

# 定义空集合
s = set()
print(s, type(s))  # set() <class 'set'>

类型转换：

# 进行类型转换时，要切记定义集合的三大注意。
# 别忘记，集合可以通过列表的类型转换list()转成列表，这也是很常见的情况。

res = set('hellolllll')

print(res)  # {'h', 'l', 'e', 'o'}

print(set([1, 1, 1, 1, 1, 1]))  # {1}

# print(set([1, 1, 1, 1, 1, 1, [11, 222]])  # 报错

print(set({'k1': 1, 'k2': 2}))  # {'k2', 'k1'}

内置方法：关系运算、去重

取交集：两者共同的好友

friends1 = {"zero", "kevin", "jason", "egon"}
friends2 = {"Jy", "ricky", "jason", "egon"}

res = friends1 & friends2
print(res)  # {'jason', 'egon'}

# 也可使用内置方法
# print(friends1.intersection(friends2))

取并集/合集：两者所有的好友

friends1 = {"zero", "kevin", "jason", "egon"}
friends2 = {"Jy", "ricky", "jason", "egon"}

print(friends1 | friends2)
#{'jason', 'kevin', 'egon', 'zero', 'Jy', 'ricky'}

# 也可使用内置方法
# print(friends1.union(friends2))

取差集：取friends1独有的好友、取friends2独有的好友

friends1 = {"zero", "kevin", "jason", "egon"}
friends2 = {"Jy", "ricky", "jason", "egon"}

# 取friends1独有的好友
print(friends1 - friends2)  # {'zero', 'kevin'}

# 也可使用内置方法
# print(friends1.difference(friends2))

#-------------------------------------------------------------#

# 取friends2独有的好友
print(friends2 - friends1)  # {'ricky', 'Jy'}

# 也可使用内置方法
#print(friends2.difference(friends1))

取对称差集: 求两个用户独有的好友们（即各种去掉共有的好友然后取并集）

friends1 = {"zero", "kevin", "jason", "egon"}
friends2 = {"Jy", "ricky", "jason", "egon"}

# print((friends1 - friends2)|(friends2 - friends1))
print(friends1 ^ friends2)  # {'Jy', 'zero', 'ricky', 'kevin'}

# 也可使用内置方法
# print(friends1.symmetric_difference(friends2))

父子集：包含与被包含的关系

s1 = {1, 2, 3}
s2 = {1, 2, 4}
# 不存在包含关系，下面两个比较均为False
print(s1 > s2)  # False
print(s1 < s2)  # False

s1 = {1, 2, 3}
s2 = {1, 2}
print(s1 > s2)  # True  当s1大于或等于s2时，才能说是s1是s2他爹
# print(s1.issuperset(s2))  # True
# print(s2.issubset(s1))  # s2 < s1  =>True

s1 = {1, 2, 3}
s2 = {1, 2, 3}
print(s1 == s2)  # True  s1与s2互为父子
# print(s1.issuperset(s2))  # True
# print(s2.issuperset(s1))  # True

长度

s = {'a', 'b', 'c'}
print(len(s))  # 3

成员运算

s = {'a', 'b', 'c'}
print('a' in s)  # True
print('b' not in s)  # False

循环

s = {'a', 'b', 'c'}
for item in s:
    print(item)
    
# b
# c
# a

discard()

# 删除元素，存在就删除，不存在就do nothing
s = {1, 2, 3}
s.discard(3)
print(s)  # {1,2}

# remove()也是删除，不过当元素不存在时就会报错
# s.remove(4)  # 程序报错

update()

# 更新集合
s = {1, 2, 3}
s.update({1,3,5})
print(s)  # {1, 2, 3, 5}

pop()

# 随机删除，并返回删除的值
res = s.pop()
print(res)

add()

# 添加元素
s.add(66)
print(s)

两个了解的方法

s = {1, 2, 3}
res = s.isdisjoint({3, 4, 5, 6})  # 两个集合完全独立、没有共同部分，返回True
print(res)  # False

s.difference_update({3, 4, 5})  # s = s.difference({3,4,5})
# 取s相对于集合{3, 4, 5}独有的部分，再覆盖赋值给s自己
print(s)  # {1, 2}

集合可以去重，但是有局限性。

只能针对不可变类型去重

print(set([1,1,1,1,2]))  # {1, 2}

无法保证原来的顺序

l = [1, 'a', 'b', 'z', 1, 1, 1, 2]
l = list(set(l))
print(l)  # 每一次都是随机顺序  ['b', 1, 'z', 2, 'a']

利用循环对可变类型进行去重，而且保留顺序：

l = [
    {'name': 'lili', 'age': 18, 'sex': 'male'},
    {'name': 'jack', 'age': 73, 'sex': 'male'},
    {'name': 'tom', 'age': 20, 'sex': 'female'},
    {'name': 'lili', 'age': 18, 'sex': 'male'},
    {'name': 'lili', 'age': 18, 'sex': 'male'},
]
new_l = []
for dic in l:
    if dic not in new_l:
        new_l.append(dic)

print(new_l)

总结：

Python打印数据类型 python打印int型数据_Python打印数据类型

本文参考文章：https://zhuanlan.zhihu.com/p/108793771

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：python脚本把文件信息放到一行 python将信息存入文本

下一篇：java 定时任务存取数据 java定时任务实现原理

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

Python打印数据 类型 python打印int型数据

Python打印数据 类型 python打印int型数据

Python-基本数据类型的常用内置方法

一、数字类型

int类型

定义：

类型转换：

float类型

定义：

类型转换：

二、字符串类型（重要）

定义：

类型转换：str可以把任意其他类型都转成字符串

内置方法：Python的字符串是不可变类型，所以通过内置方法得到的字符串并不是改变了原字符串，而是产生了新的字符串。

1. 按索引取值(正向取+反向取) ：只能取不能改

2. 切片：索引的拓展应用，从一个大字符串中 拷贝 出一个子字符串

3. 长度len

4. 成员运算in和not in

5. 移除字符串左右两侧的符号strip

6. 切分split：把一个字符串按照某种分隔符进行切分，得到一个列表

7. 循环

8. strip，lstrip，rstrip

9. lower，upper

10. startswith，endswith

11. format

12. split，rsplit：将字符串切成列表

13. join：把列表拼接成字符串

14. replace

15. isdigit

16. find，rfind，index，rindex，count

17. center，ljust，rjust，zfill

18. expandtabs

19. captalize，swapcase，title

20. is数字系列

21. is其他

三、列表类型（有序）

作用：按位置存放多个值

类型转换：但凡能够被for循环遍历的类型都可以当做参数传给list()转成列表

内置方法

按索引存取值(正向存取+反向存取)：即可以取也可以改

切片(顾头不顾尾，步长)

长度

成员运算in和not in

往列表中添加值

追加

指定位置插入值

l.extend()

删除

方式一：通用的删除方法，只是单纯的删除、没有返回值

方式二：l.pop()根据索引删除，会返回删除的值

方式三：l.remove()根据元素删除，返回None(主观上相当于无返回值)

循环

l.copy

l.count()

l.index()

l.clear()

l.reverse()：不是排序，而是将列表倒过来(反转)

l.sort(): 列表内元素必须是同种类型才可以排序，不然会报错

列表实现队列与堆栈

队列：FIFO(First In, First Out)，先进先出

堆栈：LIFO(Last In, First Out)，后进先出

四、元组类型(就是一个“不可变的列表”，有序，属于不可变类型)

作用：按照索引/位置存放多个值，只用于读不用于改

定义：（ ）内用逗号分隔开多个任意类型的元素j

类型转换：

内置方法：

按索引取值（正向取+反向取）：只能取

切片（顾头不顾尾，步长）（切片是一种拷贝操作）

长度

成员运算in和not in

循环

index()

count()

五、字典类型（无序）

定义：{ }内用逗号分隔开多个 key：value，其中 value 可以使任意类型，但是 key 必须是不可变类型，且不能重复。

造字典的方式一：

造字典的方式二：

造字典的方式三：快速初始化一个字典

数据类型转换

内置方法

Python打印数据类型 python打印int型数据

Python打印数据类型 python打印int型数据

2. 切片：索引的拓展应用，从一个大字符串中拷贝出一个子字符串

定义：（）内用逗号分隔开多个任意类型的元素j