Python数据类型

Number（数字）

主要包括了整数，浮点数（小数）和复数。

###整数
Python可以处理任意大小的整数，当然包括负整数，在程序中的表示和在数学中的写法是一致的。

num1 = 10
num2 = num1
# 连续定义多个变量
num3 = num4 = num5 =1
# 交互式赋值定义变量
num6,num7 = 6,7

浮点数

浮点数由整数部分和小数部分组成，浮点数运算可能会有四舍五入的误差。

f1 = 1.1 
f2 = 2.2
print("f1+f2")

输出结果为:3.3000000000000003

复数

复试是由实数部分和虚数部分构成，可以用a+bj来表示。

常见的数学功能

import math
import random

# 返回数字的绝对值
a1 = -10
a2 = abs(a1)
print("a1的绝对值为:%d" % a2)

# 比较两个数的大小
a3 = 30
a4 = 50
print("两个数大小比值的结果为:%d" % ((a3 > a4)-(a3 < a4)))

# 返回给定参数的最大值
print("返回最大值:%d" % max(1, 2, 3, 4, 5, 6, 7))

# 返回给定参数的最小值
print("返回最小值:%d" % min(12, 34, 21, 55))

# 求x的y次方
print("2的五次方结果为:%d" % (pow(2, 5)))

# round四舍五入,round(x[,n])返回浮点数的四舍五入的值，如果给出n值，则代表四舍五入到小数点后n位
print("3.456四舍五入的结果为:%.2f" % round(3.456))
print("3.456四舍五入的结果为:%.2f" % round(3.456, 2))

# 向上取整
print("向上取整的结果为:%d" % math.ceil(18.1))
print("向上取整的结果为:%d" % math.ceil(18.9))

# 向下取整
print("向下取整的结果为:%d" % math.floor(18.1))
print("向下取整的结果为:%d" % math.floor(18.9))

# 返回整数部分与小数部分
print("小数部分为:%f,整数部分分别为:%d " % math.modf(22.3))

# 开平方
print("16开平方的结果为:%d" % math.sqrt(16))

# 随机数，从列表中随机取出一个数
print("列表中取的随机数为:%d" % random.choice([1, 3, 5, 7, 9]))
print("列表中取的随机数为:%d" % random.choice(range(5)))  # range(5) == [0,1,2,3,4]
print(random.choice("beautiful"))  # beautiful girl == ["b","e","a","u","t","i","f","u","l"]

# random.randrange([start,] stop[,step]) 从指定范围内，按指定的基数递增的集合中选取一个随机数
# start--指定范围的开始值，包含在范围内，默认是0；stop--指定范围的结束值，但是不包含在范围内;
# step--指定的递增基数，默认是1
print("从递增的奇数中取出的随机数为:%d" % random.randrange(1, 100, 2))

# 从0-99中选取一个随机数
print("从0-99中取出的随机数为:%d" % random.randrange(100))

# 随机生成[0,1)之间的数（浮点数）
print("[0,1)之间的随机数为:%f" % random.random())

list = [1, 2, 3, 4, 5]
# 将序列的所有元素随机排序
random.shuffle(list)
print(list)

# 随机生成一个实数，它的范围在[5,6]之间
print("5和6之间的实数为:%f" % random.uniform(5, 6))

运行结果如下：

a1的绝对值为:10
两个数大小比值的结果为:-1
返回最大值:7
返回最小值:12
2的五次方结果为:32
3.456四舍五入的结果为:3.00
3.456四舍五入的结果为:3.46
向上取整的结果为:19
向上取整的结果为:19
向下取整的结果为:18
向下取整的结果为:18
小数部分为:0.300000,整数部分分别为:22 
16开平方的结果为:4
列表中取的随机数为:5
列表中取的随机数为:2
b
从递增的奇数中取出的随机数为:25
从0-99中取出的随机数为:9
[0,1)之间的随机数为:0.937621
[2, 3, 1, 5, 4]
5和6之间的实数为:5.146058

String（字符串）

字符串是以单引号或双引号括起来的任意文本，比如说：“abcd”,‘weddd’。

# 创建字符串
str1 = "he is a handsome man!"
str2 = "she is a beautiful girl!"
str3 = "he falls love with her!"

字符串运算

# 字符串连接
str1 = "he is a handsome man!"
str2 = "she is a beautiful girl!"
str3 = "he falls love with her!"
str4 = str1 + str2 + str3
print(str4)

输出结果为：he is a handsome man!she is a beautiful girl!he falls love with her!

# 输出重复的字符串
print(str1 * 3)

输出结果为：he is a handsome man!he is a handsome man!he is a handsome man!

# 访问字符串中的某一个字符
# 通过索引下标查找字符，索引从0开始字符串名[下标]
str1 = "he is a handsome man!"
print(str1[3])

# 截取字符串
# 从给定下标出开始截取给定下标之前
str2 = str1[8:16]
# 从头截取到给定下标之前
str3 = str1[:2]
print(str2)
print(str3)

# %s表示占位符
print("str3 = %s" % str3)

# 转义字符\，将一些字符转换成有特殊含义的字符
print('he is a \'good\' man')
print("he is a \"good\" man")

# \n表示换行符,\t表示制表符
print("he is a\tgood man")

# 如果字符串中有好多字符需要转义，就需要加入好多的\，为了简化，Python允许使用"r"表示内部的字符串默认不转义
print(r"\\\t\\")

# eval(str)
# 功能：将字符串str当成有效的表达式来求值并返回计算结果
number = eval("123456")
print(number)
print(type(number))
print(eval("+12456"))
print(eval("45-30"))

输出结果为：

i
handsome
he
str3 = he
he is a 'good' man
he is a "good" man
he is a	good man
\\\t\\
123456
<class 'int'>
12456
15

# len(str)返回字符串的长度(字符个数)
print(len("he is a good man!"))

# lower(str)转换字符串中大写字母为小写字母
str1 = "He Is a Good man!"
print(str1.lower())
print(str1)

# upper()转换字符串中小写字母为大写字母
str1 = "He is a good man!"
print(str1.upper())

# swapcase()转换字符串中大写字母为小写字母，小写字母为大写字母
str1 = "He Is a Good man!"
print(str1.swapcase())

# capitalize()首字母大写，其他字母均是小写
str1 = "she is a beautiful girl!"
print(str1.capitalize())

# title()每个单词的首字母大写
str1 = "she is a beautiful girl!"
print(str1.title())

# center(width[, fillchar])返回一个指定宽度的居中对齐的字符串，fillchar为填充的字符串，默认是空格填充
str1 = "she is a beautiful girl!"
print(str1.center(40))

# ljust(width[, fillchar])返回一个指定宽度的左对齐的字符串，fillchar为填充的字符串，默认是空格填充
str1 = "she is a beautiful girl!"
print(str1.ljust(40))

# rjust(width[, fillchar])返回一个指定宽度的右对齐的字符串，fillchar为填充的字符串，默认是空格填充
str1 = "she is a beautiful girl!"
print(str1.rjust(40))

# zfill(width)返回一个长度为width的字符串，原字符串右对齐，前面补0
str1 = "she is a beautiful girl!"
print(str1.zfill(40))

# count(str[, start][,end])返回字符串中str出现的次数，使用start指定开始的位置，end指定结束的位置，默认从头到尾
str1 = "she is a beautiful she girl!"
print(str1.count("she", 3, len(str1)))

# find(str[,start][,end])从左向右检测str字符串是否包含在字符串中，可以指定范围，默认从头到尾，
# 得到的是第一次出现的开始下标，没有返回-1
str1 = "she is a beautiful girl!"
print(str1.find("is"))
print(str1.find("good"))

# rfind(str[,start][,end])从右向左检测str字符串是否包含在字符串中，可以指定范围，默认从头到尾，
# 得到的是第一次出现的开始下标，没有返回-1
str1 = "she is a beautiful girl!"
print(str1.rfind("is"))

# index(str, start=0, end=len(str))与find()一样，如果str不存在时会报异常
str1 = "she is a beautiful girl!"
print(str1.index("a"))

# rindex(str, start=0, end=len(str))与find()一样，如果str不存在时会报异常
str1 = "she is a beautiful girl!"
print(str1.rindex("a"))

# lstrip()截掉字符串左侧指定的字符，默认是空格
str1 = "****she is a beautiful girl!*********"
print(str1.lstrip("*"))

# rstrip()截掉字符串右侧指定的字符，默认是空格
str1 = "*******she is a beautiful girl!        "
print(str1.rstrip(), "*")


# strip()截掉字符串左右侧指定的字符，默认是空格
str1 = "***********she is a beautiful girl!********"
print(str1.strip("*"))

输出的结果如下：

17
he is a good man!
He Is a Good man!
HE IS A GOOD MAN!
hE iS A gOOD MAN!
She is a beautiful girl!
She Is A Beautiful Girl!
        she is a beautiful girl!        
she is a beautiful girl!                
                she is a beautiful girl!
0000000000000000she is a beautiful girl!
1
4
-1
4
7
11
she is a beautiful girl!*********
*******she is a beautiful girl! *
she is a beautiful girl!

Boolean（布尔值）

一个布尔值只有真和假（True和False）两种情况，

a = True
b = False
print(a, b)

输出结果为：True False

None（空值）

空值：是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊值。

c = None
print(c)

输出结果为：None

list（列表）

列表是一种有序的集合。
创建列表 列表名 = [列表选项1, 列表选项2, 列表选项3,…,列表选项n]

# 创建列表 列表名 = [列表选项1, 列表选项2, 列表选项3,...,列表选项n]
list = []
print(list)

# 创建带有元素的列表
list1 = [18, 23, 45, 67, 86, 23]

# 注意：列表中的元素数据可以是不同类型的
list2 = [1, 2, "she", "nice", True]
print(list2)

# 列表元素的访问 取值格式：列表名[下标]  注意：不要越界(下标超出了可表示的范围)
list3 = [23, 34, 45, 12]
print(list3[1])

# 替换
list3[2] = 50
print(list3)

# 列表组合
list4 = [2, 3, 5]
list5 = [1, 2, 3]
list6 = list4 + list5
print(list6)

# 列表的重复
list7 = [4, 5, 6]
print(list7 * 3)

# 判断元素是否在列表中
list8 = [65, 23, 45, 67]
print(23 in list8)
print(30 in list8)

# 列表截取
list9 = [3, 2, 5, 6, 8, 1]
print(list9[1:5])
print(list9[2:])
print(list9[:5])

# 二维列表
list10 = [[2, 3, 4, 5], [12, 13, 14, 15], [23, 23], [32, 34]]
print(list10[1])
print(list10[2][1])

# 添加元素 append 在列表中末尾添加新的元素
list11 = [23, 34, 32, 43, 56]
list11.append(86)
print(list11)
list11.append([21, 23, 12])
print(list11)

# 在末尾一次性追加列表中的多个值
list12 = [23, 34, 32, 43]
list12.extend([21, 32, 32])
print(list12)

# 在下标处添加一个元素，不覆盖原数据，原数据向后顺延
list13 = [23, 34, 32, 43] 
list13.insert(3, 33)
list13.insert(2, [20, 32])
print(list13)

# pop(x=list[-1]) 移除列表中指定下标处的元素（默认移除最后一个元素），并返回删除的数据
list14 = [4, 5, 6, 7, 8]
list14.pop()
print(list14.pop(3))
print(list14)

# remove 移除列表中某个元素中第一个匹配的结果
list15 = [20, 21, 22, 23, 24, 22]
list15.remove(22)
print(list15)

# 清除列表中所有数据
list16 = [30, 31, 32, 33, 34, 35]
list16.clear()
print(list16)

# 从列表中找出某个值第一个匹配的索引值
list17 = [40, 41, 42, 43, 44, 45, 43]
print(list17.index(43))
print(list17.index(43, 4, 7))  # 圈定范围

# 列表中的元素个数
list18 = [46, 47, 48, 49]
print(len(list18))

# 获取列表中的最大最小值
list19 = [50, 51, 52, 53, 54, 55]
print(max(list19))
print(min(list19))

# 查看元素在列表中出现的次数
list20 = [56, 57, 58, 59, 57, 56, 57, 58, 56]
print(list20.count(57))
num = 0
all = list20.count(57)
while num < all:
    list20.remove(57)
    num += 1
print(list20)

# 倒叙
list21 = [60, 61, 62, 63, 64]
list21.reverse()
print(list21)

# 排序
list22 = [65, 66, 67, 68, 69]
list22.sort()
print(list22)

# 拷贝  浅拷贝
list23 = [70, 71, 72, 73, 74]
list24 = list23
list24[1] = 75
print(list24)
print(list23)

# 深拷贝
list25 = [75, 76, 77, 78, 79]
list26 = list23.copy()
list26[1] = 80
print(list26)
print(list25)

输出结果为：

"[]
[1, 2, 'she', 'nice', True]
34
[23, 34, 50, 12]
[2, 3, 5, 1, 2, 3]
[4, 5, 6, 4, 5, 6, 4, 5, 6]
True
False
[2, 5, 6, 8]
[5, 6, 8, 1]
[3, 2, 5, 6, 8]
[12, 13, 14, 15]
23
[23, 34, 32, 43, 56, 86]
[23, 34, 32, 43, 56, 86, [21, 23, 12]]
[23, 34, 32, 43, 21, 32, 32]
[23, 34, [20, 32], 32, 33, 43]
7
[4, 5, 6]
[20, 21, 23, 24, 22]
[]
3
6
4
55
50
3
[56, 58, 59, 56, 58, 56]
[64, 63, 62, 61, 60]
[65, 66, 67, 68, 69]
[70, 75, 72, 73, 74]
[70, 75, 72, 73, 74]
[70, 80, 72, 73, 74]
[75, 76, 77, 78, 79]

Process finished with exit code 0

tuple（元组）

# 创建空元组
tuple1 = 0
print(tuple1)

# 创建带有元素的元组  元组中的元素的类型可以使不同的类型
tuple2 = (1, 2, 3, "nice", False)
print(tuple2)

# 定义只有一个元素的元组
tuple3 = (2, )
print(tuple3)
print(type(tuple3))

# 元组元素的访问  元组名[下标]  下标从0开始，下标不可以越界
tuple4 = (4, 5, 6, 7, 8)
print(tuple4[2])
print(tuple4[-1])  # 获取最后一个元素
print(tuple4[-5])  # 获取第一个元素

# 修改元组
tuple5 = (9, 10, 11, [12, 13])
# tuple5[2] = 12  # 元组不能改变
tuple5[-1][1] = 12  # 元组里的元素如果是可变的，则可以修改
print(tuple5)

# 删除元组 删除后没有该元组，系统会报错
tuple6 = (14, 15, 16, 17, 18)
del tuple6
print(tuple)

# 元组的相加
tuple7 = (19, 20, 21, 22, 23)
tuple8 = (24, 25, 26, 27, 28)
tuple9 = tuple7 + tuple8
print(tuple9)

# 元组重复
tuple10 = (29, 30)
print(tuple10 * 3)

# 判断元素是否在元组中
tuple11 = (31, 32, 33, 34, 35)
print(36 in tuple11)

# 元组的截取 元组名[开始下标，结束下标] 从开始下表哦开始截取，截取到结束下标之前
tuple12 = (36, 37, 38, 39, 40)
print(tuple12[1:3])
print(tuple12[:2])
print(tuple12[2:])

# 二维元组
tuple13 = ((41, 42), (43, 44), (45, 46))
print(tuple13[1][1])  # 取出44

# 元组的方法   返回元组中元素的个数
tuple14 = (47, 48, 49, 50)
print(len(tuple14))

# 返回元组中的最大最小值
tuple15 = (51, 52, 53, 54, 55)
print(max(tuple15))
print(min(tuple15))

# 将列表转元组
list1 = [56, 57, 58, 59, 60]
tuple16 = tuple(list1)
print(tuple16)

# 元组的遍历
for i in (61, 62, 63, 64):
    print(i)

输出结果为：

0
(1, 2, 3, 'nice', False)
(2,)
<class 'tuple'>
6
8
4
(9, 10, 11, [12, 12])
<class 'tuple'>
(19, 20, 21, 22, 23, 24, 25, 26, 27, 28)
(29, 30, 29, 30, 29, 30)
False
(37, 38)
(36, 37)
(38, 39, 40)
44
4
55
51
(56, 57, 58, 59, 60)
61
62
63
64

dict（字典）

'''
使用键-值(key-value)存储，具有极快的查找速度， 字典是无序的
特性：
1.字典中的key是唯一的，是不可变的对象  字符串 ，整数等都是不可变的，可以作为key，
 最多的是使用字符串来作为key  list是可变的，不可作为key
'''

# 保存多个学生的姓名和成绩  将多个字典放在一个列表中
dict1 = [{"name": "张三",
          "score": 98},
         {"name": "李四",
          "score": 88}]
print(dict1)

dict2 = {"张三": 98,
         "李四": 88,
         "王五": 78}
print(dict2)

# 元素的访问  字典名[key]
print("李四的成绩为:%d" % dict2["李四"])
print(dict2.get("刘六"))  # 设置没有这个key时，不会报错  若没有这个key，则输出None

# 元素的添加
dict2["吕金亚"] = 68
print(dict2)

# 元素的修改
dict2["吕金亚"] = 98  # 一个key对应一个value，多次对一个key赋值，则修改该key的值
print(dict2)

# 元素的删除
dict2.pop("吕金亚")
print(dict2)

# 字典的遍历
for key in dict2:
    print(key, dict2[key])

for value in dict2.values():
    print(value)

for key, value in dict2.items():
    print(key, value)

for x, v in enumerate(dict2):  # 排序
    print(x, v)

# 和list比较
# 1.字典的查找和插入的速度较快，不会随着key-value的增加而变慢
# 2.字典需要占用大量的内存，内存浪费多

a = input()
dict3 = {}  # word:次数
str1 = "Children are expected to obey different rules either at home or at school!" \
       "Strict discipline is sometimes important,but it would have an adverse impact on" \
       "children's problem solving abilities"
l = str1.split(" ")
for v in l:
    c = dict3.get(v)
    if c == None:
        dict3[v] =1
    else:
        dict3[v] += 1
print(dict3)

# 以空格切割字符串
# 循环处理列表中的每个元素
# 以元素当做key去一个字典中提取数据
# 如果没有提取到，就以该元素作为key，1作为value存进字典
# 如果提取到，将对应的key的value修改，值加1
# 根据输入的字符串当做key再去字典取值

输出结果如下所示：

[{'name': '张三', 'score': 98}, {'name': '李四', 'score': 88}]
{'张三': 98, '李四': 88, '王五': 78}
李四的成绩为:88
None
{'张三': 98, '李四': 88, '王五': 78, '吕金亚': 68}
{'张三': 98, '李四': 88, '王五': 78, '吕金亚': 98}
{'张三': 98, '李四': 88, '王五': 78}
张三 98
李四 88
王五 78
98
88
78
张三 98
李四 88
王五 78
0 张三
1 李四
2 王五
a
{'Children': 1, 'are': 1, 'expected': 1, 'to': 1, 'obey': 1, 'different': 1, 'rules': 1, 'either': 1, 'at': 2, 'home': 1, 'or': 1, 'school!Strict': 1, 'discipline': 1, 'is': 1, 'sometimes': 1, 'important,but': 1, 'it': 1, 'would': 1, 'have': 1, 'an': 1, 'adverse': 1, 'impact': 1, "onchildren's": 1, 'problem': 1, 'solving': 1, 'abilities': 1}

set（集合）

set:类似dict，是一组key的集合，不存储value。本质：无序。无重复元素的集合

# 创建set需要一个list或者tuple或者dict作为输入集合 重复元素在set中会自动被过滤
set1 = set([1, 2, 3, 4, 5, 3, 1, 2])
print(set1)

set2 = set((6, 7, 8, 9, 10, 1, 2, 3))
print(set2)

set3 = set({"name":"张三", "age": 18})
print(set3)

# set的添加   set的元素不能是列表和字典，因为这两者是可变的
set4 = set([11, 12, 13, 14])
set4.add(15)
set4.add((11, 12, 13))
print(set4)

# 插入整个list、tuple、字符串，打碎擦好人
set5 = set((16, 17, 18, 19))
set5.update([20])
set5.update((14, 15))
set5.update("you")
print(set5)

# set的删除
set5 = set((21, 22, 23, 24, 25, 26))
set5.remove(26)
print(set5)

# set的循环遍历
set6 = set([26, 27, 28, 29, 30])
for s in set6:
    print(s)
# set没有索引

for index, data in enumerate(set6):
    print(index, data)

set7 = set([31, 32, 33, 34, 35, 36])
set8 = set([35, 36, 37, 38, 39, 40])
# 交集
And = set7 & set8
print(And)

# 并集
Join = set7 | set8
print(Join)

输出结果如下所示：

{1, 2, 3, 4, 5}
{1, 2, 3, 6, 7, 8, 9, 10}
{'name', 'age'}
{11, 12, 13, 14, 15, (11, 12, 13)}
{'y', 14, 15, 16, 17, 18, 19, 20, 'u', 'o'}
{21, 22, 23, 24, 25}
26
27
28
29
30
0 26
1 27
2 28
3 29
4 30
{35, 36}
{32, 33, 34, 35, 36, 37, 38, 39, 40, 31}