python_数据类型

变量

变量定义程序就是用来处理数据的，而变量就是用来存储数据的；

命名规则：在 Python 中，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建，变量定义之后，后续就可以直接使用了；

等号（=）用来给变量赋值
`=` 左边是一个变量名
`=` 右边是存储在变量中的值

变量名再次出现，不是定义变量，而是直接使用之前定义过的变量，在程序开发中，可以修改之前定义变量中保存的值。

变量的类型

在内存中创建一个变量，会包括：
1. 变量的名称
2. 变量保存的数据
3. 变量存储数据的类型
4. 变量的地址（标示）

在 Python中定义变量是不需要指定类型（在其他很多高级语言中都需要）数据类型可以分为数字型和数字型

数字型:整型 (`int`)、浮点型（`float`）、布尔型（`bool`）真 True非零即真，假 `False` `0`、复数型 (`complex`)主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题；

非数字型：字符串、列表、元组、字典；

使用 `type` 函数可以查看一个变量的类型

'''
用户输入苹果单价元/斤
用户输入买了几斤苹果
计算付款金额
如果只要买苹果，就返 5 块钱'''
price=eval(input("请输入苹果单价："))
weight=eval(input("请输入苹果重量："))
money=price*weight
money-=5
print(money)

'''
* 定义变量保存小明的个人信息
* 姓名：**小明**
* 年龄：**18** 岁
* 性别：**是**男生
* 身高：**1.75** 米
* 体重：**75.0** 公斤
'''
name ="小明"
age = 18
sex = True
height = 1.75
weight = 75
print(f"姓名：{name}\n年龄：{age}\n性别：{sex}\n身高：{height}米\n体重：{weight}公斤！")
print(type(name))

数据类型

1、标准数据6类型：number、string、list、typle、set、dictionary.

2、可迭代的数据类型：

可变序列（两个）：List（列表）、Dictionary（字典）、Sets（集合）。

不可变序列（四个）：Number（数字）、String（字符串）、Tuple（元组）；

不可迭代数据类型

数字类型：int float
布尔类型：bool

3、什么叫可迭代序列

可以被for循环遍历得对象
或者说isinstance([1,2,3],Iterable)为True得的对象

4、什么叫可变序列

可变序列：支持原位置改变
不可变序列：不支持原位改变

数字类型

整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。

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

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

浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 10² = 250）
复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型。

#数字类型
a=2
print(type(a))   ##type()是查看数据类型的方法

#获取用户输入
name=input("name:")
age=int(input("age:"))
salary=float(input("salary:"))
print(name,age,salary)

类型转换：

不同类型变量之间的计算，数字型变量之间可以直接计算

如果变量是 `bool` 型，在计算时`True` 对应的数字是 `1`，`False` 对应的数字是 `0`

数据类型的转换，你只需要将数据类型作为函数名即可

# 1,两个数字型变量是可以直接进行算数运算的
i = 10
f = 10.5
t = True
print(i+f)
print(i*t)

# 2,在字符串之间可以使用 `+` 拼接生成新的字符串
first_name = "三"

last_name = "张"
print(last_name+first_name)

# 3,字符串变量可以和整数使用重复拼接相同的字符串
print("=="*30)

# 4，数字型变量和字符串之间不能进行其他计算
first_name = "zhang"
x = 10
print(x + first_name)   #报错TypeError: unsupported operand type(s) for +: 'int' and 'str'

# 5，类型转换
b=1.0
print(int(b))  #将b转换为一个整数。
c=2
print(float(c))   #将c转换为一个浮点数。

数学函数

#以下是数学运算
print(abs(-40))   #abs() 函数返回数字的绝对值,可以是整数，浮点数，复数,结果：40

print(max(80, 100, 1000))  #max() 方法返回给定参数的最大值，参数可以为序列，结果：1000

print(min(80, 100, 1000))  #min() 方法返回给定参数的最小值，参数可以为序列，结果：80

print(round(100.000056, 3)) #round() 方法返回浮点数x的四舍五入值;结果：100.0

import math
print(math.ceil(-45.17))#ceil(x) 函数返回一个大于或等于 x 的的最小整数,结果：-45

print(math.exp(-45.17))  #exp() 方法返回x的指数,结果：2.4150062132629406e-20

#fabs() 和abs() 函数，区别:abs() 是内置函数。 fabs() 函数在 math 模块中定义。fabs() 函数只对浮点型跟整型数值有效。 abs() 还可以运用在复数中。
print(math.fabs(-45.17))#fabs() 方法返回数字的绝对值，结果：45.17

print(math.floor(-45.17)) #floor(x) 返回数字的下舍整数，小于或等于 x;结果：-46 如100.25返回100

print(math.log(100.12))   #log() 方法返回x的自然对数，x > 0。结果：4.6063694665635735

print(math.log10(100.12)) #log10() 方法返回以10为基数的x对数，x>0。结果：2.0005208409361854

print(math.modf(100.12))   #modf() 方法返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示；结果：(0.12000000000000455, 100.0)

print(math.pow(2, 4))   #pow() 方法返回 xy（x的y次方） 的值;结果：16.0

print(math.sqrt(100))   #sqrt() 方法返回数字x的平方根。结果：10.0

View Code

随机函数

#随机函数
import random
print(random.random())#random() 方法返回随机生成的一个实数，它在[0,1)范围内。结果：0.8018257012330915

print(random.choice(range(100)))      #0
print(random.choice([1, 2, 3, 5, 9]))   #结果：2
print(random.choice('Runoob'))   #choice() 方法返回一个列表，元组或字符串的随机项  结果u

#random.randrange ([start,] stop [,step]) ，代表开始值，结束值，递增值
print(random.randrange(1, 100, 2))#randrange() 方法返回指定递增基数集合中的一个随机数，基数缺省值为1。结果：97

#shuffle() 方法将序列的所有元素随机排序。 结果：[20, 16, 10, 5]
list = [20, 16, 10, 5];
random.shuffle(list)
print (list)

print(random.uniform(5, 10))#uniform() 方法将随机生成下一个实数，它在[x,y]范围内 结果：9.846804730004338

View Code

字符串

在python中加了引号的字符串都被认为是字符串，注意：字符串的拼接只能是双方都是字符串，不能跟数字或其它类型拼接。

字符串常用方法：

在 标识符 / 数据后输入一个 .，然后按下 TAB 键，iPython 会提示该对象能够调用的 方法列表

str.

str.capitalize( str.isalpha( str.ljust( str.split(

str.casefold( str.isascii( str.lower( str.splitlines(

str.center( str.isdecimal( str.lstrip( str.startswith(

str.count( str.isdigit( str.maketrans( str.strip(

str.encode( str.isidentifier( str.partition( str.swapcase(

str.endswith( str.islower( str.replace( str.title(

str.expandtabs( str.isnumeric( str.rfind( str.translate(

str.find( str.isprintable( str.rindex( str.upper(

str.format( str.isspace( str.rjust( str.zfill(

str.format_map( str.istitle( str.rpartition(

str.index( str.isupper( str.rsplit(

str.isalnum( str.join( str.rstrip(

1) 判断类型 - 9

2) 查找和替换 - 7

3) 大小写转换 - 5

4) 文本对齐 - 3

5) 去除空白字符 - 3

6) 拆分和连接 - 5

练习：

str = "Hello Python"
print(str[4])     #字符串根据索引查询

#统计
print(len(str))         #统计长度
print(str.count("o"))   #统计某一个小（子）字符串出现的次数
print(str.index("llo"))  # 某一个子字符串出现的位置，如果使用index方法传递的子字符串不存在，程序会报错！

#判断类型
str_a = "   \t\n\r"
print(str_a.isspace())   #判断是否只包含空格，只有空格返回True，\t\n\r也属于空白字符
#判断字符串中是否只包含数字1> 都不能判断小数 2> unicode 字符串 3> 中文数字
str_b = "1.1"
str_c = "\u00b2"
str_d = "一千零一"
print(str_b.isdecimal())   #只包含数字则返回 True,小数点不能判断
print(str_c.isdigit())     #只包含数字则返回 True，`全角数字`、`⑴`、`\u00b2`
print(str_d.isnumeric())   #只包含数字则返回 True，`全角数字`，`汉字数字`

#查找和替换 - 7
hello_str = "hello world,hello"
print(hello_str.startswith("hello"))   # 判断是否以指定字符串开始
print(hello_str.endswith("world"))     # 判断是否以指定字符串结束
# index同样可以查找指定的字符串在大字符串中的索引
print(hello_str.find("llo"))    #查找指定字符串，index如果指定的字符串不存在，会报错。find如果指定的字符串不存在，会返回-1

print(hello_str.replace("world", "python",1))    # 替换字符串replace方法执行完成之后，会返回一个新的字符串，注意：不会修改原有字符串的内容
print(hello_str)     #原字符串还是hello world

#大小写转换
s1 = 'my Pleasure'
print(s1.capitalize())   #把字符串的第一个字符大写
print(s1.title())        #把字符串的每个单词首字母大写
print(s1.lower())        #转换 string 中所有大写字符为小写
print(s1.upper())        #转换 string 中的小写字母为大写
print(s1.swapcase())     #翻转 string 中的大小写

#去除空白字符
name='*barry**'
print(name.strip('*'))
print(name.lstrip('*'))
print(name.rstrip('*'))

#文本对齐
# 要求：顺序并且居中对齐输出以下内容
poem = ["\t\n登鹳雀楼",
         "王之涣",
         "白日依山尽\t\n",
         "黄河入海流",
         "欲穷千里目",
         "更上一层楼"]

for poem_str in poem:

    # 先使用strip方法去除字符串中的空白字符
    # 再使用center方法居中显示文本
    print("|%s|" % poem_str.strip().center(10, "　"))

#字符串拼接
# 1. 将字符串中的空白字符全部去掉
# 2. 再使用 " " 作为分隔符，拼接成一个整齐的字符串
poem_str = "登鹳雀楼\t 王之涣 \t 白日依山尽 \t \n 黄河入海流 \t\t 欲穷千里目 \t\t\n更上一层楼"
print(poem_str)
# 1. 拆分字符串
poem_list = poem_str.split()
print(poem_list)

# 2. 合并字符串
result = " ".join(poem_list)
print(result)


#字符串遍历
for c in str:
    print(c)

文本序列 str 字符串

字面值---可以用单引号‘’，也可以使用双引号“”；三引号多行声明："""多行字符串"""
转义符----\n 换行；
\t 加空格，一个Tab距离；
\ 转义 \ ；
r"\d\df\ff" r开头的字符串，忽略转义符；
\b 退格；
\r 回车；
' 避免字符串内单引号的歧义；
" 避免字符串内双引号的歧义；
? 转义一个？；
\0 空字符；

name='花花'  #单引号
name2="小明"  #双引号
str=name+name2  #字符串拼接
msg = "My name is flowers , I'm 22 years old!"  #区分单引号和双引号
 #多行字符串必须用多引号
print(msg)
msg1 = '''
三引号用于换行，
可以试试
'''
print(msg1)
print(name,name2,str)
print(name2[:1]+"蓝")   #字符更新
print(name*10)     #相乘其实就是复制自己多少次，再拼接在一起
print('"你好，世界"') #字符串中包含双引号
print('"My name is flowers ", I\'m 22 years old!' )    #包含双引号和单引号，单引号使用了转义符
print('hello\nworld')   #\n表示换行
print(str(1234) + "\n" + str(4321))  #混合使用数字和字符串并且换行
print(repr("hello\nworld"))   # 按原始字符串输出，使用repr函数
print(repr(r"hello\nworld"))

字符串的索引与切片

切片方法适用于字符串、列表、元组，切片使用索引值来限定范围，从一个大的字符串中切出小的字符串；

列表和元组都是有序的集合，都能够通过索引值获取到对应的数据；

字典是一个无序的集合，是使用键值对保存数据；

字符串[开始索引:结束索引:步长]

注意：

1. 指定的区间属于左闭右开型 `[开始索引, 结束索引)` => `开始索引 >= 范围 < 结束索引`>从 `起始` 位开始，到结束位的前一位结束（不包含结束位本身)

2. 从头开始，开始索引数字可以省略，冒号不能省略；
3. 到末尾结束，结束索引数字可以省略，冒号不能省略；
4. 步长默认为 `1`，如果连续切片，数字和冒号都可以省略‘

索引的顺序和倒序在 Python 中不仅支持顺序索引同时还支持倒序索引，所谓倒序索引就是从右向左计算索引最右边的索引值是 -1，依次递减

num_str = "0123456789"

# 1. 截取从 2 ~ 5 位置 的字符串
print(num_str[2:6])

# 2. 截取从 2 ~ `末尾` 的字符串
print(num_str[2:])

# 3. 截取从 `开始` ~ 5 位置 的字符串
print(num_str[:6])

# 4. 截取完整的字符串
print(num_str[:])

# 5. 从开始位置，每隔一个字符截取字符串
print(num_str[::2])

# 6. 从索引 1 开始，每隔一个取一个
print(num_str[1::2])

# 倒序切片
# -1 表示倒数第一个字符
print(num_str[-1])

# 7. 截取从 2 ~ `末尾 - 1` 的字符串
print(num_str[2:-1])

# 8. 截取字符串末尾两个字符
print(num_str[-2:])

# 9. 字符串的逆序
print(num_str[::-1])

格式化输出

将一个值插入到一个有字符串格式符 %s 的字符串中，%是占位符，s替换字符串类型，d替换成数字类型；c格式化字符及其ASCII码；

#格式化输入的三种方法
name=input("用户：")
age=int(input("年龄："))
height=input("身高:")
print("我叫%s,今年%d,身高%s,学习进度为3%%"%(name,age,height)) #格式化输入中用到%号时，再加一个%格式化输出
print(f"我叫{name},今年{age},身高{heght},学习进度为30%")
print("我叫{},今年{},身高{},学习进度为30%".format(name,age,height))
#换行打印
msg = '''-----------start---------
我叫: %s
今年：%s
身高：%d
-----------end-----------'''%(name,age,height)
print(msg)

比较大小

在比较字符串大小时，会按ASCII顺序比较，小写大于大写

a="hello"
b="Hello"
print(bool(a>b))

布尔值（True，False）

真或假,1 或 0

print(bool(1))    #输出： True
print(bool([1,2,3]))#输出： True
print(bool([]))  #输出： False

List（列表）

`List`（列表）：是 `Python` 中使用最频繁的数据类型，在其他语言中通常叫做数组，专门用于存储一串信息，列表用 `[]` 定义，数据之间使用 `,` 分隔，列表的索引从 `0` 开始，索引又可以被称为下标。注意：从列表中取值时，如果超出索引范围，程序会报错；

可包含任意对象的有序集合
可以通过下标索引访问某一个元素
可变长度，异质（包含各种类型），可任意嵌套（可在套入一个list）
支持原位改变
对象引用数组

1.序列都可以进行的操作包括索引，切片，加，乘，检查成员。第一个索引是0，第二个索引是1，依此类推。

列表常用操作：

| 序号 | 分类 | 关键字 / 函数 / 方法 | 说明 |
1 、增加

2、修改

列表[索引] = 数据 | 修改指定索引的数据 |

3 、删除

4 、统计

len(列表) | 列表长度 |
列表.count(数据) | 数据在列表中出现的次数 |
5 、排序

list1 = ['lucky', 'Library','python', 1997, 2000,'python']
list2 = [1, 2, 3, 4, 5, 6, 7,8,9,44,55,44,100]
list3 = [321,22,102,35,52,22,99,12]

#查询，1、根据索引查询，以及切片查询（结束索引不包含在内） 2、使用index方法查询某值匹配位置
print(list1[0])
print(list1[0:3])     ##从第0个元素开始截取列表['lucky', 'Library', 'python']
print(list1[-2])      #倒数第二个元素2000
print(list1[3:])      #从索引3开始到结束[1997, 2000, 'python']
print(list1[-4:])     #['python', 1997, 2000, 'python']
print(list1[:-4])     #['lucky', 'Library']
print(list1[1::2])    #从索引1开始到结束位置，步长为2，隔一个元素取一次
print(list1.index(2000))

#修改更新，根据索引位置修改值
list1[3]=2019
print(list1)

#新增,1、在指定索引位置插入数据，2、在末尾追加数据，3、将另外一个列表的数据追加到list1
list1.insert(1,"perfect")
list1.append("hello")
list1.extend(list2)
print(list1)

#删除数据 del删除指定索引的数据，2、remove删除第一个出现的指定数据 3、pop删除末尾数据 带(索引)：删除指定索引数据 4、列表.clear清空列表
del list2[1]
list2.remove(44)
list2.pop()   # list2.pop(-1)
#list2.clear()
print(list2)

#统计  1、len 列表长度 2、列表.count数据在列表中出现的次数
print(len(list3))
print(list3.count(22))

#排序 1、列表.sort()升序排序 2、sort(reverse=True)降序排序 3、reverse()逆序、反转
list3.sort(reverse=True)
print(list3)
list3.reverse()
print(list3)

#遍历列表
for li in list3:
    print(li)

列表函数

len() 方法返回列表元素个数.语法：len(list)

max() 方法返回列表元素中的最大值。语法：max(list)

min() 方法返回列表元素中的最小值。语法：min(list)

cmp() 方法用于比较两个列表的元素。语法：cmp(list1, list2)

list() 方法用于将元组转换为列表。

list3 =['python','hello',54,78,'zara']
list4 =[1,5,32,55,14]
tuple1=('Google', 'Runoob', 1997, 2000)
print(len(list3))  #返回元素个数
print(min(list4))   #返回元素最小值
print(max(list4))    #返回元素最大值
print(tuple(list4))   #将列表转换成元组
print(list(tuple1))   #将元组返回列表

列表方法：

>>> list1.

list1.append( list1.count( list1.insert( list1.reverse(

list1.clear( list1.extend( list1.pop( list1.sort(

list1.copy( list1.index( list1.remove(

列表操作常用操作包含以下方法:
1、list.append(obj)：在列表末尾添加新的对象
2、list.count(obj)：统计某个元素在列表中出现的次数
3、list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4、list.index(obj)：从列表中找出某个值第一个匹配项的索引位置
5、list.insert(index, obj)：将对象插入列表
6、list.pop(obj=list[-1])：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7、list.remove(obj)：移除列表中某个值的第一个匹配项
8、list.reverse()：反向列表中元素
9、list.sort([func])：对原列表进行排序

aList = [123, 'xyz', 'zara', 'abc',123];

bList = [2009, 'manni']
clist =[33,42,'abc']
vowels = ['e', 'a', 'u', 'o', 'i']

aList.append(2019)  #在列表末尾添加新的对象
print(aList)
print(aList.count(123))  #统计某个元素在列表中出现的次数

aList.extend(bList)    #函数用于在列表末尾一次性追加另一个序列中的多个值
print(aList)

print(aList.index('xyz'))   #从列表中找出某个值第一个匹配项的索引位置

clist.insert(1,556)    #将对象插入指定位置列表
print(clist)

clist.pop()     #用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
print(clist)

clist.remove(556)               #函数用于移除列表中某个值的第一个匹配项

print(clist)

aList.reverse()     #reverse() 函数用于反向列表中元素。
print(aList)

vowels.sort(reverse=True)    #函数用于对原列表进行排序,True为降序，False升序
print(vowels)

clist.clear()
print(clist)    #清空列表

dlist=bList.copy()      #copy列表
print(dlist)

列表练习：

li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
# 计算列表的长度并输出
print(len(li))
# 列表中追加元素"seven",并输出添加后的列表
li.append('seven')
# 请在列表的第1个位置插入元素"Tony",并输出添加后的列表
li.insert(0,'Tony')

# 请修改列表第2个位置的元素为"Kelly",并输出修改后的列表
li[2]='Kelly'
# 请将列表l2=[1,"a",3,4,"heart"]的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
l2=[1,"a",3,4,"heart"]
li.extend(l2)
# 请将字符串s = "qwert"的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
s = "qwert"
li.extend(s)
#print(li)
# 请删除列表中的元素"ritian",并输出添加后的列表
li.remove('ritian')
print(li)
# 请删除列表中的第2个元素，并输出删除的元素和删除元素后的列表
li_pop = li.pop(1)  # 指定的是下标位置
print(li_pop, li)
# 请删除列表中的第2至4个元素，并输出删除元素后的列表
for i in range(2, 5):
    li.pop(1)
print(li)

列表嵌套

作用：你需要存储大量的数据，且需要这些数据有序的时候。

li = ['hello', 'seven', ["mon", ["h", "Kelly"], 'all'], 123, 446]
# 请根据索引输出'Kelly'
print(li[2][1][1])

# 请使用索引找到'all'元素并将其修改为'ALL'
li[2][2] = 'ALL'
print(li)

l1 = [1, 2, 'taibai', [1, 'flower', 3,]]
# 1, 将l1中的'taibai'变成大写并放回原处。
#l1[2]='TAIBAI'    #方法一：直接修改
#方法二
print(l1[2].upper())   #使用upper()方法
l1[2]= l1[2].upper()
print(l1)
# 2，给小列表[1,'alex',3,]追加一个元素,'星星'。
l1[3].append('星星')
print(l1)
# 3，将列表中的'flower'通过字符串拼接的方式在列表中变成'flowerss'
print(l1[-1][1])
l1[-1][1]=l1[-1][1]+'ss'
print(l1)

Tuple（元组）

Python的元组与列表类似，但元组的元素不能修改。但我们可以对元组进行连接组合；

元组使用小括号，列表使用方括号。元组中只包含一个元素时，需要在元素后面添加逗号；

元组中的元素值是不允许删除的，可以使用del语句来删除整个元组；

使用下标索引值来查询元素。元组内置函数同列表函数一样，没有方法

任意无符号的对象，以逗号隔开，默认为元组

可包含任意对象的有序集合；
通过下标索引（位置偏移）访问元素；固定长度，异变，可任意嵌套；
对象引用数组。

#创建元组
info = ()  #空元组
info1 = (32,)  #元组中只包含一个元素时，需要在元素后面添加逗号来消除歧义
info2 = ("小米",12,1.70)
info3 = "a", "b", "c", "d";  #不加括号也可以
info5 = (1,2,3,4,5,6,7)

#访问元组
print(info2[2])    #访问第三个元素
print(info3[1:3])   #('b', 'c')
print(info3[-1])
print(info2.index("小米"))   #访问数值匹配索引位置

#修改元组，不能修改，只能组合新的元组
info4=info2+info3
print(info4)

#删除元组
del info4
#print(info4)     #删除后再次输出会报异常

#元祖内置函数
print(info2.count(12))
print(len(info2))
print(max(info5))
print(min(info5))

#元组转换列表
print(list(info5))

#列表转换元组
aList = [123, 'xyz', 'zara', 'abc',123];
print(tuple(aList))

#切片
tu1 = ('a', 'b', 'flowers', 3, 666)
print(tu1[0])  # 'a'
print(tu1[-1])  # 666
print(tu1[1:3])  # ('b', 'flowers')
print(tu1[:-1])  # ('a', 'b', 'flowers', 3)
print(tu1[::2])  # ('a', 'flowers', 666)
print(tu1[::-1])  # (666, 3, 'flowers', 'b', 'a') 

#遍历元组
for i in info2:
    print(i)
    
#拓展：格式化字符串后边的（）本身就是元组
tu=("小李",22)
print("%s 的年龄是 %d" % tu)

知识扩充：

#交换数字
a = 6
b = 100
# 解法 1 - 使用临时变量
c = b
b = a
a = c

# 解法 2 - 不使用临时变量
a = a + b
b = a - b
a = a - b

# 解法 3 —— Python 专有，利用元组
a, b = b, a

Dictionary（字典）

列表的缺点：

1. 列表可以存储大量的数据类型，但是如果数据量大的话，他的查询速度比较慢。2. 列表只能按照顺序存储，数据与数据之间关联性不强。

`dictionary`（字典）是除列表以外`Python` 之中最灵活的数据类型字典,同样可以用来存储多个数据,通常用于存储描述一个 `物体` 的相关信息 ;缺点：他的缺点就是内存消耗巨大；

列表的区别:列表是有序的对象集合;字典是无序的对象集合;

语法：字典用 `{}` 定义,字典使用键值对存储数据，键值对之间使用 `,` 分隔；键：`key` 是索引，必须是唯一的，值：`value` 是数据，可以取任何数据类型，但键只能使用字符串、数字或元组；

函数

len() 方法计算元素个数

str() 方法输出字典可打印的字符串表示

type() 方法返回输入的变量类型

方法

在 `ipython3` 中定义一个字典，例如：`dic1 = {}`输入 `dic1.` 按下 `TAB` 键，`ipython` 会提示字典能够使用的函数如下：

dic1.

dic1.clear( dic1.get( dic1.pop( dic1.update(

dic1.copy( dic1.items( dic1.popitem( dic1.values(

dic1.fromkeys( dic1.keys( dic1.setdefault(

clear() 函数用于删除字典内所有元素。

copy() 函数返回一个字典的浅复制

fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。

get() 函数返回指定键的值，如果值不在字典中返回默认值。

has_key() 函数用于判断键是否存在于字典中，如果键在字典dict里返回true，否则返回false。

items() 函数以列表返回可遍历的(键, 值) 元组数组

keys() 函数以列表返回一个字典所有的键。

update() 函数把字典dict2的键/值对更新到dict里

values() 函数以列表返回字典中的所有值。

创建字典的几种方式；

#方式一
dic1 = dict((('one',1),('tow',2),('three',3)))
#dic = dict([('one', 1),('two', 2),('three', 3)])
print(dic1)       # {'one': 1, 'tow': 2, 'three': 3}


#方式二：
dic2 = dict(one=1,two=2,three=3)
print(dic2)       # {'one': 1, 'tow': 2, 'three': 3}

#方式三：
dic3 = dict({'one':1,'two':2,'three':3})
print(dic3)       # {'one': 1, 'tow': 2, 'three': 3}

#方式5
dic5 = dict(zip(['one','two','three'],[1,2,3]))
print(dic5)        # {'one': 1, 'tow': 2, 'three': 3}


# 方式6: 字典推导式
dic6 = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}
print(dic6)

#方式7：
dic7 = dict.fromkeys('abcd','flowes')
print(dic7)  # {'a': 'flowes', 'b': 'flowes', 'c': 'flowes', 'd': 'flowes'}
dic77 = dict.fromkeys([1, 2, 3],'flowers')
print(dic77)  # {1: 'flowers', 2: 'flowers', 3: 'flowers'}

字典的增删改查

#创建字典，
personal = {"name": "小明",
            "age": 18,
            "gender": True,
            "height": 1.75}
dic1 = {"phone":10086}

dic2 = {"student":3865,"classlesson":325,"le":11,"ff":"e"}

#访问字典
print(personal.keys())   #获取所有key列表
print(personal.values())  #获取所有key列表
print(personal.items())   #获取所有key,values元组列表
print(personal["name"])     #从字典中取值，没有值就会报错
print(personal.get("name"))    #从字典中取值，没有值就会报错

#修改字典,1、key存在修改数据，不存在就新增建值对，2、setdefault方法同上 3、update将字典2的数据合并到字典1
personal["name"]="小赵"
personal["性别"]="girl"
personal.setdefault("address","北京市")
personal.update(dic1)
print(personal.items())

#删除
del dic2["ff"]         #删除指定键值对，没有key报错
dic2.pop('le')   #删除指定键值对，没有key报错
dic2.popitem()   #删除随机键值对
dic2.clear()     #清空字典
print(dic2)

#内置函数
print(len(personal))     #计算字典元素个数，即键的总数。
print(str(personal))     #输出字典，以可打印的字符串表示。
print(type(personal))    #返回变量类型

#浅拷贝
dict4 = {'Name': '小小', 'Age': 7, 'Class': 'First'}
dict5 = dict4.copy()
print("新复制的字典为 : ", dict5)

#遍历
for k in dict4:
    print("%s: %s" % (k, dict4[k]))

''' 尽管可以使用 `for in`遍历字典,但是在开发中，更多的应用场景是：使用多个键值对,存储 **描述一个 `物体` 的相关信息—— 描述更复杂的数据信息
将多个字典放在一个列表中，再进行遍历，在循环体内部针对每一个字典进行相同的处理'''
card_list = [{"name": "张三",
              "qq": "12345",
              "phone": "110"},
             {"name": "李四",
              "qq": "54321",
              "phone": "10086"}
             ]
for li in card_list:
    print(card_list)

字典嵌套

dic = {
    'name':['alex','wusir','taibai'],
    'py9':{
        'time':'1213',
        'learn_money':19800,
        'addr':'CBD',
           },
    'age':21
}
dic['age']=56   #修改
print(dic['age'])
dic['name'].append('huahau')   #添加
print(dic['name'])
l = [1,2,'wusir']
l[2] = l[2].upper()
dic['name'][1] = dic['name'][1].upper()
print(dic)

嵌套练习：

dic = {
    'name':'汪峰',
    'age':48,
    'wife':[{'name':'国际章','age':38}],
    'children':{'girl_first':'小苹果','girl_second':'小怡','girl_three':'顶顶'}
}
#
# 1. 获取汪峰的名字。
print(dic.get('name'))
#print(dic['name'])
# 2.获取这个字典：{'name':'国际章','age':38}。
print(dic['wife'][0])
# 3. 获取汪峰妻子的名字。
print(dic['wife'][0]['name'])
# 4. 获取汪峰的第三个孩子名字。
print(dic['children'].get('girl_three'))
#print(dic['children']['girl_three'])

集合set

容器型的数据类型，它要求里面的元素是不可变的数据，但是它本身是可变的数据类型，集合是无序的{};

集合的作用：

　　去重，把一个列表变成集合，就自动去重了。

　　关系测试，测试两组数据之前的交集、差集、并集等关系。

#集合创建
#set1 = set({1,2,'barry','flowers',67})
set2 = {1,2,'barry','flowers',67}
print(type(set2),set2)   #<class 'set'> {1, 2, 67, 'barry', 'flowers'}

#空集合
print({},type({}))   #空字典
set3 = set()         #空集合
print(type(set3),set3)

#集合添加
set4 = {22,33,44,'flower','小星'}
set4.add('python')    # 添加
set4.update('A')      #update：迭代着增加
set4.update([1,2,3])
print(set4)

#删除
set5 = {'alex','wusir','ritian','egon','barry'}
set5.remove('alex')  # 删除一个元素
set5.pop()     # 随机删除一个元素
set5.clear()   # 清空集合
#del set5  # 删除集合
print(set5)

#交集（&  或者 intersection）
setj = {1,2,3,4,5}
setj1 = {4,5,6,7,8}
print(setj & setj1)   # {4, 5}
print(setj.intersection(setj1))

#并集（| 或者 union）
setb = {1,2,3,4,5}
setb1 = {4,5,6,7,8}
print(setb | setb1)  # {1, 2, 3, 4, 5, 6, 7, 8}
print(setb.union(setb1))

#差集（- 或者 difference）
setc = {1,2,3,4,5}
setc1 = {4,5,6,7,8}
print(setc - setc1)   #{1, 2, 3}
print(setc.difference(setc1))

#反交集（^ 或者 symmetric_difference）
setf = {1,2,3,4,5}
setfj = {4,5,6,7,8}
print(setf ^ setfj)  #{1, 2, 3, 6, 7, 8}
print(setf.symmetric_difference(setfj))

#子集与超集
seta = {1,2,3}
setb = {1,2,3,4,5,6}

print(seta < setb)
print(seta.issubset(setb))  # 这两个相同，都是说明set1是set2子集。

print(setb > seta)
print(setb.issuperset(seta))  # 这两个相同，都是说明set2是set1超集。

#frozenset不可变集合，让集合变成不可变类型。
s = frozenset('barry')
print(s,type(s))  # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>

#练习列表去重
l1=[1,1,1,2,2,2,3,3,'flowers',4,4,4,'flowers',7,7,7,7,10,10,10,10]
set1 = set(l1)
print(set1)
l1 = list(set1)
print(l1)

公共方法：

切片

| 切片 | "0123456789"[::-2] | "97531" | 字符串、列表、元组 |

切片使用索引值来限定范围，从一个大的字符串中切出小的符串；
列表和元组都是有序的集合，都能够通过索引值获取到对应的数据
字典是一个无序的集合，是使用键值对保存数据；

运算符

| 运算符 | Python 表达式 | 结果 | 描述 | 支持的数据类型 |
| + | [1, 2] + [3, 4] | [1, 2, 3, 4] | 合并 | 字符串、列表、元组 |
| * | ["Hi!"] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 | 字符串、列表、元组 |
| in | 3 in (1, 2, 3) | True | 元素是否存在 | 字符串、列表、元组、字典 |
| not in | 4 not in (1, 2, 3) | True | 元素是否不存在 | 字符串、列表、元组、字典 |
| > >= == < <= | (1, 2, 3) < (2, 2, 3) | True | 元素比较 | 字符串、列表、元组 |

注意

`in` 在对字典操作时，判断的是字典的键
`in` 和 `not in` 被称为成员运算符

range：类似于列表，自定制范围，生成指定数字

for i in range(10):   #从0开始到9
    print(i)
for i in range(1,10):
    print(i)

for i in range(1,10,2):   #步长
    print(i)

for i in range(10,1,-2): # 反向步长
    print(i)

l1 = ['flowers', 'python', '嗯哼', '二熊', 12, 666]
for i in range(len(l1)):
    print(i)

小练习：
l1 = range(5)
print(l1[1:3])    #range(1, 3)
print(l1)         #range(0, 5)
print(l1[-1])     #-4

for i in range(1,5,-1):
    print(i)         #无内容

深浅copy

赋值运算

对于赋值运算来说，l1与l2指向的是同一个内存地址，l1,l2指向的是同一个列表，任何一个变量对列表进行改变，剩下那个变量在使用列表之后，这个列表就是发生改变之后的列表。

l1 =[1,2,3,[22,33]]
l2 = l1
l1.append(666)
print(l1,id(l1))   #[1, 2, 3, [22, 33], 666] 4562870216
print(l2,id(l2))   #[1, 2, 3, [22, 33], 666] 4562870216

浅拷贝copy

浅copy来说，只是在内存中新开辟了一个空间存放这个copy的新列表，但是列表里面的内容还是沿用之前对象的内存地址，所以l1、l2的ID 不同但是内容ID 相同。

#浅copy
l1 =[1,2,3,[22,33]]
l2 = l1.copy()
l1.append(666)   #在大列表中增加的新元素
print(l1)     # [1, 2, 3, [22, 33], 666]
print(l2)     # [1, 2, 3, [22, 33]]

l1 =[1,2,3,[22,33]]
l2 = l1.copy()
l1[-1].append(666)   #在小列表中增加的新元素
print(l1,id(l1))     # [1, 2, 3, [22, 33], 666]
print(l2,id(l2))     # [1, 2, 3, [22, 33], 666]


l1 =[1,2,3,[22,33]]
l2 = l1.copy()
l1[0]=90             #更改元素内容
print(l1,id(l1))     # [90, 2, 3, [22, 33]] 4404289352
print(l2,id(l2))     # [1, 2, 3, [22, 33]] 4405465800
print(id(l1[0]))
print(id(l2[0]))

深拷贝deepcopy。

对于深copy来说，列表是在内存中重新创建的，列表中可变的数据类型是重新创建的，列表中的不可变的数据类型是公用的。

#深copy特性：将可变的数据类型在内存中重新创建一份，而不可变的数据烈性沿用之前的
import copy
# l1 =[1,2,3,[22,33]]
# l2 = copy.deepcopy(l1)
# l1.append(666)
# print(l1,id(l1))    # [1, 2, 3, [22, 33], 666] 4421239496
# print(l2,id(l2))    # [1, 2, 3, [22, 33]] 4421393032

l1 =[1,2,3,[22,33]]
l2 = copy.deepcopy(l1)
l1[-1].append(666)
print(l1,id(l1))     # [1, 2, 3, [22, 33, 666]] 4350223240
print(l2,id(l2))     # [1, 2, 3, [22, 33]] 4350089608

练习

l1 =[1,2,3,[22,33]]
l2 = l1[:]
l1[-1].append(666)
print(l1)    # [1, 2, 3, [22, 33, 666]]
print(l2)    # [1, 2, 3, [22, 33, 666]]

浅copy：嵌套的可变数据类型是同一个。

深copy：嵌套的可变的数据类型不是同一个。

练习题：

goods = [
    {"name":"电脑","price":1999},
    {"name":"鼠标","price":10},
    {"name":"游艇","price":20},
    {"name":"美女","price":998},
]
# count = 1
# for i in goods:
#     print(count,i['name'],i['price'])
#     count+=1
#
# for index in range(len(goods)):
#     print(index+1,goods[index]['name'],goods[index]['price'])

while True:
    for num,dic in enumerate(goods):
        print('{}\t{}\t{}'.format(num+1,dic['name'],dic['price']))
    choice_num = input('请输入商品序号：').strip()
    '''
    带字母的情况排除、超出范围的排除、q或者Q退出、1-4正确的序号根据相应商品
    '''
    if choice_num.isdecimal():#判断只包含数字
        choice_num = int(choice_num)
        if 0 < choice_num<=len(goods):
            print(f"您选择的商品名{goods[choice_num-1]['name']},价格为{goods[choice_num-1]['price']}")
        else:
            print('您输入的超出范围，请重新输入')
    elif choice_num.upper()=='Q':break
    else:
        print('您输入了非字母元素，请重新输入：')


#循环提示用户输入，并将输入内容追加到列表中，如果输入n或者N退出循环，并打印列表中用户输入内容
#
# l1 = []
# while 1:
#
#     content = input('>>>')
#     if content.upper() == 'N':break
#     l1.append(content)
# print(l1)
#扩展
l1 = []
while 1:

    username = input('请输入用户名：')
    if username.upper() == 'N':break
    password = input('请输入密码：')
    dic = {}
    dic['username'] = username
    dic['password'] = password
    l1.append(dic)
print(l1)


#看代码写结果并解释原因
# data = {}
# for i in range(10):  #0-9
#     data['user']=i
# print(data)    #{'user': 9}

#看代码写结果并解释原因
data_list = []
data = {}
for i in range(10):
    data['user']= i
    data_list.append(data)
print(data)     # {'user': 9}

#请用代码验证name是否在字典的健当中？
info= {'name':'flowers','sex':'女','age':12}
#print('name' in info)
print('name' in info.keys())

#
v1 = {'k1':'v1','k2':[1,2,3]}
v2 = {'k1':'v1','k2':[1,2,3]}
result1 = v1 == v2
result2 = v1 is v2
print(result1)   # True
print(result2)   # False

posted on 2017-11-02 17:27 flowerszhao 阅读(376) 评论(0) 编辑收藏举报

刷新页面返回顶部