python 数据打印 python如何打印数据类型

---

目录：

数值（number）

布尔（bool）

字符串（char）

列表（list）

元组（tuple）

字典（dict）

集合（set）

None（特殊的数据类型）

---

一：数值（number）

数值类型在Python中有如下几种：

1.int：整型
2.long：长整型（Python3已经废弃）
3.Float：浮点型
4.complex：复数型

代码例子如下：

a = 4 # int整型类型
print( type( a ) ) # type类可以用来查看对象类型
# 打印结果如下：
<class 'int'>

b = 22.3 # Floot浮点类型
print( type( b ) ) 
# 打印结果如下：
<class 'float'>

c = -1j # complex复数类型
print( type( c ) )
# 打印结果如下：
<class 'complex'>

二：布尔类型（bool）

布尔类型只有两个值：True和False

True：真
False：假

例子如下：

print ( 2 > 1 )
print ( 1 > 2 )
print ( type ( 2 > 3 ) ) # type类用来测试数据类型
# 打印结果如下：
True
False
<class 'bool'>

布尔值有很多用处，在第三章Python（3）——Python的运算符中的“逻辑运算符中”有详细介绍。

三：字符串（char）

在Python中最常处理的数据类型就是字符串，在Python中字符串的格式是用单引号、双引号、三对单引号包裹起来的，是一种不可变的数据类型。例子如下：

a = 'Hello'
b = "HI"
c = ''' He sad , " I'm OK" '''

在打印字符的时候通常会用\n、\t等作为转义字符实现特殊的效果。

例如：\n是换行，\t是制表符等等。例子如下：

print( 'hello\nHi\tHello' ) # 碰到\n自动换行，\t填充制表符
# 打印结果如下：
hello
Hi  Hello

如果想要将转义字符当成普通字符来处理，则在转义字符前再使用“\”转义即可，例子如下：

print ( 'HI\nHello' )
print ( 'I\tOK' )
print ( 'I\\t\\nOK' ) # 使用转义字符将特殊字符转为普通字符
# 打印结果如下：
HI
Hello
I  OK
I\t\nOK

字符串中很多可以用转义字符来显示出特殊效果（/n换行，/t制表符等），如果想要将特殊的字符当做普通字符来处理时，则需要在转义字符前面再使用转义字符进行转义。这样有一个缺点，就是在处理大量字符数据的时候非常麻烦，所以Python支持了另一种“原生字符”（原生字符原样打印）的写法，例子如下：

print ( r'\n\thello' ) # 在Pyhon中字符前面加r表示是原生字符串，里面的转义字符都作为普通字符串处理
# 打印结果如下：
\n\thello

Python中还支持将字符串作为二进制数值来处理，例子如下：

a = b'hello' # 字符前面加字符b表示以二进制来保存
print ( type ( a ) ) 
print ( a )
# 打印结果如下：
<class 'bytes'>  # 显示a的类型
b'hello'

# 下面是第二种方法：
b = 'hello'.encode( 'utf-8' ) # encode方法可以将字符串转为二进制
print ( b )
# 打印结果如下：
b'hello'

将汉字转为二进制数值存储，例子如下：

c = '你'.encode( 'utf-8' )
print ( c )
# 打印结果如下：
b'\xe4\xbd\xa0'

字符串转为二进制使用encode方法，而二进制转为字符串则使用decode方法，例子如下：

c = b'\xe4\xbd\xa0'.decode( 'utf-8' ) # 'utf-8'是编码和解码格式
print( c )
# 打印结果如下：
你

需要注意的是二进制转为字符串使用的编码格式，要和字符串转为二进制的编码格式保持相同，不然会出现乱码。

因为计算机所有的数据都是作为二进制来存储的，在’utf-8’的编码中，汉字“你”的编码就是上面十六进制，之所以不是二进制，是因为十六进制更好处理。

（扩充知识：编码格式有很多中，其中utf-8是国际上标准的编码方式，汉语之前有自己的编码方式，是gb2312，gbk,等等，它们之间区别在于，之前gb2312一个汉字占两个字节，而utf-8中一个汉字占3个字节。）

上面介绍了字符串的基本知识，下面介绍字符串的下标和切片。

字符串的下标和切片：

a = 'abcdefg' # 数据在计算机中存储下标索引都是从0开始
print ( len ( a ) ) # 可以通过len函数来测试长度
# 打印结果如下：
7

从上面我们知道了字符串是有下标索引的，那么就可以通过下标来获取对应的字符，以变量a为例：

a = 'abcdefg'
print ( a [ 2 ] ) # a[n]代表获取a变量中下标为2的字符
# 打印结果如下：
c

上面通过下标索引来获取数据，而切片也是如此，例子如下：

a = 'abcdefg'
print ( a [ 2 : 4 ] )  # a[2:4]表示[2,4)，切片都是包含开头不包含结尾
# 打印结果如下：
cd
 
 a = 'abcdefg'
print ( a [ 2 : ] ) # a[2:]表示从第二个下标一直切到结束
# 打印结果如下：
cdefg
 
a = 'abcdefg'
print ( a [ : 5 ] ) # a[:5]表示从第0个下标一直切到第5个，但是不包含第五个
# 打印结果如下：
abcde

a = 'abcdefg'
print ( a [ : ] ) # a[:]表示从第0个下标一直切到最后一个
# 打印结果如下：
abcdefg

a = 'abcdefg'
print ( a [ 2 : 5 : 2 ] ) # a[2:5:2]表示从第2个下标切到第五个，下标值相隔为2切一次。不包含5
# 打印结果如下：
ce

a = 'abcdefg'
print ( a [ 5 : 2 : -1 ] ) # 步长为负数，表示从右往左取。'abcdefg'则就是从f-d，反过来取
# 打印结果如下：
fed

a = 'abcdefg'
print ( a [ -5 : -2 ] ) # 都为负数表示从左往右，从倒数第五个开始到倒数第二个，包含开始不包含结束
# 打印结果如下：
cde

a = 'abcdefg'
print ( a [ -2 : -5 : -1 ] ) # 从倒数第二个取到倒数第五个，从右往左（只要步长为负数都是从右往左）
# 打印结果如下：
fed

a = 'abcdefg'
print ( a [ : : -1 ] )  # 表示从右往左取完
# 打印结果如下：
gfedcba

（前面我们说字符串是不可变的数据类型，怎么可以对它进行切片呢，其实这里的不可变类型是指，数据没有改变原来的值，即a还是之前的’abcdefg’。）

下面介绍字符串的常见方法：

介绍字符串方法之前，我们要知道一句名言，“在java中万物皆是对象”这句话放在Python中也同样适用（Python也是面向对象编程语言）。我们创建了字符串，然后就可以字符串对象所拥有的方法。

代码例子如下：

a = 'hello,world'
a.len() # len是测试长度的方法
a.count('l') # conunt方法用来统计字符串中字符出现了多少次
a.encode('utf-8') # encode方法用来将字符串转为二进制
a.find('o')   # find用来在字符串中查找第一个字符o/字符串的下标，若查找不到则返回-1
a.rfind('o') # rfind用来在字符串中查找最后一个出现o的下标
a.index('o') # 查找指定字符在字符串中的下标
a.rindex('o') # 查找指定字符最后一个字符串中的下标
# find,rfind和index，rindex之间看起来似乎相同，但它们之间有一个不同之处在于，index在查找不到时会报错，而find则不会

字符串还支持一个运算符——“in”，“in”运算符是关系型运算符，用来查看指定的字符（字符串）是否在字符串中，返回bool类型。例如：

print ( 'wo' in 'hello,world' )
 # 打印结果如下：
 True
 ————————————————————————————————
 print ( 'hl' in 'hello,world' )
 # 打印结果如下：
 False

字符串的判断方法：

starswith：判断字符串以什么为开头

endswith：判断字符串以什么结尾

isalpha：判断对象是否全部为字母

isalnum：判断对象是否为数字和字母

isdigit：判断对象是否全部为数字

isspace：判断对象是否全部全是空格

代码例子如下：

print ( 'abc'.starswith ( 'a' ) ) # starswith是判断字符串以什么开头
# 打印结果如下
True

print ( 'abc'.endswith ( 'c' ) ) # endswith判断字符串以什么结束
# 打印结果如下：
True

print ( 'abc'.isalpha( ) ) # isalpha是判断对象是否全部为字母
# 打印结果如下：
True

print ( 'abc'.isalnum( ) ) # isalnum判断是否是为数字和字母
# 打印结果如下：
True

print ( 'abc'.isdigit( ) ) # isdigit判断是否是数字
# 打印结果如下：
False

print ( 'ab c'.isspace( ) ) # 判断是否全是空格
# 打印结果如下：
False

字符串的替换方法：replace。

replace是就地替换，不会改变原有的字符数据。代码例子如下：

a = 'abca'
x = a.replace( 'a' , 'A' )  # replace方法可以在字符串中替换字符
print ( x )
# 打印结果：
AbcA

# 上面会将字符串中所有的a替换称为A，如果只想替换一个则可以加入一个参数
print ('abca'.replace ( 'a' , 'A' , 1 ) )
# 打印结果如下：
Abca

字符串中修改大小写的方法：

capitalize：将首字母大写

title：将每个单词首字母都大写

upper：让每个单词全大写

lower：让每个单词都小写

代码例子如下：

print ( 'hello'.capitalize( ) ) #  capitalize是将首字母大写
# 打印结果如下：
Hello

print ( 'hello,world'.title( ) ) # title将每个单词首字母都大写
# 打印结果如下：
Hello,World

print ( 'hello,world'.upper( ) ) # upper让每个单词全大写
# 打印结果如下：
HELLO,WORLD

print ( 'ABCD'.lower( ) ) #让每个单词都为小写
# 打印结果如下：
abcd

字符串分割的方法：

split：根据指定的字符作为分割符

splitlines：根据换行符来作为分隔符

代码例子如下：

a = 'abcdakjjlabkkj'
b = a.split( 'a' ) # split是根据指定的字符作为分割，并以列表保存
print ( b )
# 打印结果如下：
['', 'bcd', 'kjjl', 'bkkj']

# 也可以指定分割的次数，只要再给一个参数即可：
a = 'abcdakjjlabkkj'
c = a.split( 'a' , 1 )
# 打印结果如下：
['', 'bcdakjjlabkkj']

# rsplit和split基本相同，不同之处是rsplit是从后往前，如下：
u = 'abvadgbadgagd'
y = u.rsplit( 'a' , 2 ) 
# 打印结果如下：
['abvadgb', 'dg', 'gd']


h = 'anc\ndef\nghijk\n'
print ( h.splitlines( ) ) # splitlines是根据换行符来分割
# 打印结果如下：
['anc', 'def', 'ghijk']

# 还有一种是可以保留作为分割的关键字，如下：
h = 'anc\ndef\nghijk\n'
print ( h.splitlines( True ) ) # 默认为False，不保存
# 打印结果如下：
['anc\n', 'def\n', 'ghijk\n']

从上面可以知道，split方法也可以达到splitlines方法的效果，不过split方法会在有换行的时候后面会默认增加一个空字符串。

（字符串有很多中方法，都在默认模块builtins.py文件中，可以使用Pycharm开发软件来查看）

（补充：之前在前面我们介绍了字符串是可迭代对象，也就意味着它也可以被拆包。）

四：列表（list）

列表在Python中是按照序列顺序来保存数据，这就意味着可以通过index下标来访问获取列表里的数据，列表是一种可变的数据类型。

列表在Python中是以 [ value1, value2... ]表示，如下：

name = [ 'laowang' , 'xiaoming' , 'xiaohong' ]
print ( name )
# 打印结果如下：
['laowang', 'xiaoming', 'xiaohong']

# 通过下标访问列表：
a = [ 'xiaoming', 'lisi', 'xiaohong' ]
print( a[ 1 ] ) # a[ 1 ]表示获取a列表中第二个数据，列表的下标以0开始
# 打印结果如下：
lisi

Python中list是一个内置类，可以将可迭代对象（可迭代对象有字符串，列表，元组等等）转为列表。如下：

a = list ( 'abcd' )
 print ( a )
 # 打印结果如下：
 ['a', 'b', 'c', 'd']

b = list ( ('hi','hello','nihao') ) # (n,m...)这是元组的表示，下面有详细j介绍
print ( b )
# 打印结果如下：
['hi', 'hello', 'nihao']

c = list ( { 'name' : 'lisi' , 'age' : 18 } )
print ( c )
# 打印结果如下：
['name', 'age'] # 因为字典中的只有key是唯一标识，所以打印的是key

列表的增、删、改、查方法：

因为列表中存储的数据都是有序的可变的数据序列，所以对列表的增删改查会直接影响到原始数据。

代码例子如下：

name = [ 'laowang' , 'xiaohong' , 'xiaoming' ]
# 增加元素，使用append方法向列表中追加一个元素
name.append( 'xiaohua' ) 
print ( name )
# 打印结果如下：
['laowang', 'xiaohong', 'xiaoming', 'xiaohua']

# 增加元素还有另一种方法，insert对指定下标位置进行增加元素
name = [ 'laowang' , 'xiaohong' , 'xiaoming' ]
name.insert( 2 , 'tiantian' )
print ( name )
# 打印结果如下：
['laowang', 'xiaohong', 'tiantian', 'xiaoming']

# 添加还有extend方法，是将一个可迭代对象的元素都添加到列表中
name = [ 'laowang' , 'xiaohong' , 'xiaoming' ]
name.extend( 'HIhllo' )
print ( name )
# 打印结果如下：
['laowang', 'xiaohong', 'xiaoming', 'H', 'I', 'h', 'l', 'l', 'o']
# 因为extend方法是将一个可迭代的对象加入到列表中，
# 所以可以直接将一个列表添加进去，如下：
a = [ 'a' , 'b' , 'c' ]
b = [ 'c' , 'd' , 'e' ]
a.extend(b)
print ( a )
# 打印结果如下：
['a', 'b', 'c', 'c', 'd', 'e']

# 列表之间还可以使用加法运算符，将两个列表合并成为一个列表，如下：
x = [ 'nihao' , 'hi' ]
y = [ 'sawadika' , 'kanixiwa' ]
z = x + y
print ( z )
# 打印结果如下：
['nihao', 'hi', 'sawadika', 'kanixiwa']

# 列表的删除元素：clear、pop、remove、del
x.clear() # 清空x列表中的所有元素
y.pop() # 删除指定位置上的元素（默认是最后一个），pop是有返回值的
z.remove( 'nihao' ) # remove删除指定的元素
del z[0] # 删除指定下标的元素
del z # 直接将z对象删除

# 列表的改动，列表可以通过下标直接改动，因为列表是可变数据类型。
g = [ 'hi' , 'ni' , 'you' ]
g [ 2 ] = 'me' 
print ( g )
# 打印结果如下：
['hi', 'ni', 'me']
# (列表和字符串是不同的 ，因为字符串只能获取，能更改)

# 列表的index方法，用来获取value对应的下标
f = [ 'hi' , 'hello' , 'to' ]
print ( f.index( 'to' ) ) # index是获取指定查询元素的下标，如果元素不存在，则报错
# 打印结果如下：
2

列表的嵌套：列表里面可以嵌套多个字典或多个列表等等，如下：

name = [ 
  {  'name' : 'zhangsan' , 'age' : 18 , 'hobbies' : ['drink', 'liu'] }
  { 'name' : 'wangwu' , 'age' : 19 , 'hobbies' : ['tiao', 'tt']      } 
       ]

a = [ 'to' , 'ni' , 'hi' ]
b = [ 'd' , 'no' , 're' ]
c = [ 'z' , 'b' , 'x' ]
z = [ a , b , c ] # z相当于一个二维表
# 如果想获取b列表中的'no'值只需要如下：   
print ( z[1][1] ) # 用两个下标来获取值
# 打印结果如下：
no

列表的生成式：
可以使用列表生成式来生成一个简单的列表，如下：

a = [ i for i in range( 10 ) ] # 这个生成式相当于从0-9，不停地加入到a这个空列表中
 print ( a ) 
 # 打印结果如下：
 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
b = [ i for i in range( 10 ) if i % 2 ]   
 print ( b )
 # 打印结果如下：
 [1, 3, 5, 7, 9]
 # 上面的生成式相当于如下：
 b = []
 for i in range( 10 ):
     if i % 2 :
         b.append( i ) # append方法是向列表追加一个数据
 
 c = [ (i,j) for i in range( 10 ) for j in range( 10 ) ]
 print ( c )
 # 打印结果如下：
 [(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), ...]
 
 # 一个复杂的列表生成式，要求到0-100的 [ [1,2,3],[4,5,6],[7,8,9]...]
 a = [ i for i in range( 1,101 ) ]
 b = [ a[i:i+3] for i in range( 0,100,3 ) ]
 print ( b )
 # 打印结果如下：
 [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]... [100]]

五：元组（tuple）

元组在Python中也是按照一定的顺序来存储数据的，和列表类似但它是不可变的数据类型。在Python中元组的表示方式如下：

a = ( 12, 34, 54, 53 ) # Python中的元组是以（n,m...）的形式

因为元组是不可变的数据类型，所以不能对元组进行修改，只能进行查询等操作。
元组的查询方法如下：

index：获取元组中元素的下标
count：统计指定的数据在元组中出现的次数

代码例子如下：

s = ( 100 , 34 , 45 , 43 )
print ( s.index( 100 ) ) # index方法是获取元素下标，可以给定范围，包含开头，不包含结尾
# 打印结果如下：
0

# 元组还支持另一种用于统计字符次数的方法，count
s = ( 100 , 34 , 45 , 43 )
print ( s.count ( 100 ) ) 
# 打印结果如下：
1

在Python中除了使用“（n,m...）”表示一个元组以外，还可以使用tuple内置类来将一个可迭代对象转为元组。

代码例子如下：

s = tuple ( 'hello' ) # tuple也和前面list，str类一样，接收一个可迭代对象
print ( s )
# 打印结果如下：
('h', 'e', 'l', 'l', 'o')

六：字典（dict）

字典在Python中是以键值对的方式来存储数据的，是无序的。但是可以通过键（key）来访问对应的值（value）。

在Python中是以“ { key : value，… } ”来表示一个字典。如下：

a = { 'name' : 'xiaoming' , 'age' : 18 }
# 字典（dict）是以{}为标示，里面的数据key对应value以“ ：”分割，多个元素之间使用“ ，”隔离
字典中key的值是唯一的，如果出现了同名的key时，后面的key对应的value值会覆盖前面的key对应的value，代码例子如下：

a = { 'name' : 'zhangsan' , 'age' : 18 , 'name' : 'laowang' }
print ( a )
# 字典中有两个同名的key，后面的key值会覆盖前面的
# 打印结果如下：
{'name': 'laowang', 'age': 18}

（字典里的value类型可以是任意类型的数据，但是key的类型只能是不可变数据类型如：元组，字符串，数字等。）

字典是可变的数据类型，也就意味着对字典的操作会直接更改源数据。

也就是说字典支持“ 增、删、改、查 ”等方法，如下：

字典的增加与改动，代码例子如下：

# 字典的增加，与改动
a = { 'name' : 'lisi' , 'age' : 32 , 'weight' : 123 }
a [ 'name' ] = 'zhangsan'
print ( a ) 
# 打印结果如下：
{'name': 'zhangsan', 'age': 32, 'weight': 123}

a [ 'coler' ] = 192 # 可以发现增加元素和上面修改元素一样，都是通过key来添加
print ( a ) 
# 打印结果如下：
{'name': 'lisi', 'age': 32, 'weight': 123, 'hight': 192}

# 字典也有单独的方法来实现增加key:value，那就是update方法，如下：
c = { 'name' : 'lisi' , 'age' : 18 }
d = { 'hight' : 178 , 'colour' : 'red' }
c.update( d ) # 将字典d合并到c中
print ( c )
# 打印结果如下：
{'name': 'lisi', 'age': 18, 'hight': 178, 'colour': 'red'}

字典的删除方法：
clear：用来清空一个列表
pop：删除指定key对应的value
popitem：默认自动删除字典最后一个key和value
del（del是运算符）：用来删除指定的数据
代码例子如下：
a = { 'name' : 'lisi' , 'age' : 13 }
a.clear( )
print ( a )
# 打印结果如下：
{} # 变成了一个空字典

a.pop( 'name' ) # pop用来删除指定key的值
print ( a )
# 打印结果如下：
{'age': 13} 

a = { 'name' : 'lisi' , 'age' : 13 }
a.popitem() # popitem不需要输入参数，自动删除最后一个key：value
print ( a ) 
# 打印结果如下：
{'name': 'lisi'}

a.del( 'name' ) # 通过del删除指定的数据
print ( a )
# 打印结果如下：
{'age': 13}

字典的查询方法：可以通过key方法，或者通过get方法查询键对应的值，如下：

# 字典的查询方法，因为字典是无序的，所以不能通过下标来访问数据，可以通过key来访问
a = { 'name' : 'laowang' , 'age' : 32 , 'weight' : 123 }
print ( a [ 'name' ] ) # 如果key不存在则会报错
#  打印结果如下：
laowang

# 字典中有一个方法get，用来获取key对应的value，即使key不存在也不会报错，会返回None
print ( a.get( 'age' ) )
#  打印结果如下：
32

# 字典的方法get还可以指定一个参数，用来做默认返回值，如下：
b = { 'name' : 'nik' , 'age' : 18 }
print ( b.get( 'heigth' ) # 当查询不存在的key时默认返回None，也可以更改返回值
# 打印结果如下：
None

# 也可以指定其返回值，如下：
print ( b.get( 'heigth' , 124 ) )
# 打印结果如下：
124

# 字典的get方法却不会更改其原有数据，即get方法发现了key对应的value值，会使用已有的value值，如果没有则使用默认值，如下：
b = { 'name' : 'nik' , 'age' : 18 }
print ( b.get( 'name' , 'hello' ) ) # 这里会使用已有的value值
print ( b.get( 'add' ) # 这里get会返回默认值None
print ( b.get( 'add' , 'shanghai' ) # 这里get方法会返回指定的值
print ( b ) # 这里来验证get方法并不会更改原有数据
# 打印结果如下：
nik
None
shanghai
{'name': 'nik', 'age': 18}

# 字典也支持in关系运算符来查看key是否存在，如下：
a = { 'name' : 'lisi' , 'age' : 34 }
print ( 'name' in a )
print ( 'lisi' in a ) # value并不能通过in关系运算符来查看
#  打印结果如下：
True
False

字典的遍历：

字典的遍历，遍历意味着将字典的所有元素访问一遍，可以通过 “[ key ]”来获取key值或者使用keys方法，values方法等来获取key值和value值，代码例子如下：

a = { 'name' : 'lisi' , 'age' : 34 , 'weight' : 154 }
 for s in a :
   print ( s ) # 这里通过关系运算符in拿到的数据是key，即s里面存储的是key
# 通过上面的for in 循环只能拿到key值
# 打印结果如下：
name
age
weight

a = { 'name' : 'lisi' , 'age' : 34 , 'weight' : 154 }
 for s in a :
    print ( s , a [s] , sep = ':' ) # 这里是通过[]方式来获取value
# 打印结果如下：
name:lisi
age:34
weight:154
    
# 字典还可以通过keys方法，来获取所有的key，并以列表的形式保存，可以如下：
a = { 'name' : 'lisi' , 'age' : 34 , 'weight' : 154 }
print ( a.keys() )
# 打印结果如下：
dict_keys(['name', 'age', 'weight'])

# 可以看出上面keys()方法返回的是字典的key，可以利用keys()方法来实现遍历
a = { 'name' : 'lisi' , 'age' : 34 , 'weight' : 154 }
for i in a.keys():
    print ( i , a[i] , sep = ':' ) 
# 打印结果如下：
name:lisi
age:34
weight:154

# 字典的value方法，可以获取到字典的所有value，因为value是可以重复的，所有不能通过value来反推拿到key
a = { 'name' : 'lisi' , 'age' : 34 , 'weight' : 154 }
print ( a.values() ) 
# 打印结果如下：
dict_values(['lisi', 34, 154]) # 也可以通过for in循环来获取单个value

# 字典的items方法，items获取key，value以元组的形式保存，如下：
a = { 'name' : 'lisi' , 'age' : 34 , 'weight' : 154 }
tum = a.items()
print ( tum )
# 打印结果如下：
dict_items([('name', 'lisi'), ('age', 34), ('weight', 154)])

# 可以通过for...in循环和itms方法来获取单个元组的元素，如下：
for i in a.items():
  print ( i[0] , i[1] , sep = ':' )
# 打印结果如下：
name:lisi
age:34
weight:154

# Python中还有更简单的方法，如下：
for k,v in a.items():    # Python中的拆包
    print ( k, v, sep = ':' )
# 打印结果如下：
name:lisi
age:34
weight:154    

# 字典生成式：
m = { a:b for a in range( 10 ) for b in range( a+1 ) }
print(m) 
# 打印结果如下：
{0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9}

七：集合（set）

集合在Python中是按照无序来保存数据的，集合与列表相似，但是却对数据自动的去重。在Python中set内置类可以将一个可迭代对象转为set集合。
Python中集合的表现形式如下：

a = { 'laowang' , 'lisi' , 'laowang' , 'xiaohong' } # set集合是以“{n,m...}”的形式体现的
print ( a ) 
# 打印结果如下：
{'xiaohong', 'laowang', 'lisi'}   # 自动去重

b = [ 12, 34, 54, 67, 34, 64 ]
print ( set( b ) ) # set内置类将一个可迭代对象转为set集合
# 打印结果如下：
{64, 34, 67, 12, 54} # 转为了set类型并自动去重

因为set是无序的，所以如果想对set进行排序，可以先转为list类型，再使用sort方法来进行排序。代码例子如下：

a = { 12, 34, 24, 45, 24 }
b = list( a ) # 利用list内置类将set集合转为列表
b.sort() # 转为了列表即可使用列表的sort方法
# 打印结果如下：
[12, 34, 56, 76]

# 或者使用内置函数sorted也可以实现排序，不过sorted不改变原有列表，会生成新的有序列表以返回值的方式保存如下：
a = { 4, 3, 4, 34, 56, }
b = sorted( a )
print ( a )
print ( b )
# 打印结果如下：
{56, 34, 3, 4}
[3, 4, 34, 56]

# 空set表示方式如下：
a = set ( )
print ( type ( a ) )
# 打印结果如下：
<class 'set'>
set类有很多中方法，例如：difference、update、add方法等等都可以在Python文档中查看。

八：None类型

一个特殊的类型，最常见的就是当函数没有返回值时，会返回None（也就是空）
代码例子如下：

a = print ( 'HI' ) # print函数的返回值是None
print( a )
# 打印结果如下：
None