python基础语法

python基础语法

变量

变量（variable）可以变化的标识符，实际就是类似数学的未知数，这个单词的作用可以代表程序中的数据进行使用。一般开发中，标记符有很多种，儿变量属于其中一种

x = "kiku"
print(x)
print(x)

上面的x就是一个程序中使用的变量。后面所有的代码只要遇到上面提前预设值的x都会直接提取对应的右边的实际内容。这样的话，就可以做到一改全改了。

命名规范

简单地理解，变量就是一个代号（别名），就好像我们每个人都有属于自己的名字，它的主要作用就是为了方便程序中的数据被方便地的调用而设置的。Python中变量名不是随意起的，而是要遵守一定的命名规则。

• 变量是由大小写字母（A~Z 和 a~z）、下划线和数字组成，但第一个字符不能是数字开头。
• 变量不能和 Python 中的关键字或保留字相同。
• 变量中不能包含特殊字符的，如：空格、@、% 以及 $ 等。
• 变量中的字母是严格区分大小写，开发中一般称之为对大小写敏感。
• 一般以下划线开头的变量名有特殊含义的，变量不能随便以下划线开头。
• 允许使用汉字作为变量名的（但是强烈不推荐使用，因为并不通用而且在部分计算机系统中不识别中文）

关键字与保留字

所谓的关键字是表示在Python语言中已经提前使用过用于特殊作用的单词，保留字就是将来可能被用于特殊作用的单词。

and	as	assert	break	class	continue
def	del	elif	else	except	finally
for	from	False	global	if	import
in	is	lambda	nonlocal	not	None
or	pass	raise	return	try	True
while	with	yield

执行python代码，也可以查看关键字与保留字

import keyword
print(keyword.kwlist)

⚠️注意：上面提到的，Python的变量是区分大小写的，关键字与保留字也不例外，所以if 是保留字，但 IF 就不是了。

声明变量

变量是一段有名字的连续存储空间，我们可以通过定义变量来申请并命名这样的存储空间，并通过变量的名字来使用这段存储空间，再编程语言中，将数据放入变量的过程叫赋值（Assignment）python使用等号=作为赋值运算符，具体格式为：

• 变量 = 数据

• 所谓赋值就是“代表”的意思

注释

注释就类似文章中的注解、旁白。其实就是对源代码的解释和说明，其目的是让其他开发人员能更加轻松地理解代码的作用。

注释是编写程序时，写程序的作者给一段关键性的代码进行解释或提示，能提高程序代码的可读性。一般情况下，合理的代码注释应该占源代码的 1/3 左右。

注释只是为了提高公认阅读，不会被解释器执行。

Python 支持两种写法的注释，分别是单行注释和多行注释。

#  单行注释,后面一整行不会被解释器执行成代码

"""
这是一个多行注释
三引号里面的任何内容不会被解释器执行
"""

格式

语句分隔符

就像我们写作文一样，逗号、句号等语句分隔符是非常重要的，程序也一样，要想让解释器能读懂，语句和语句之间一定要有分隔符。在C、Java等语言的语法中规定，必须以分号(;)作为语句结束的标识。Python也支持分号，同样用于一条语句的结束标识。但在Python中分号的作用已经不像C、Java中那么重要了，Python中的分号可以省略，主要通过换行来识别语句的结束。

缩进

和其它程序设计语言（如 Java、C 语言）采用大括号“{}”分隔代码块不同，Python 采用冒号（ : ）和代码缩进和来区分代码块之间的层次。在 Python 中，对于类定义、函数定义、流程控制语句、异常处理语句等，行尾的冒号和下一行的缩进，表示下一个代码块的开始，而缩进的结束则表示此代码块的结束。

注意，Python 中实现对代码的缩进，可以使用4个空格或者 Tab 键实现。但无论是手动敲空格，还是使用 Tab 键，通常情况下都是采用 4 个空格长度作为一个缩进量（默认情况下，一个 Tab 键就表示 4 个空格）。

只有遇到：class，def，with，if，for，while等关键字

规范

Python 采用 PEP 8 作为编码规范，其中 PEP 是 Python Enhancement Proposal（Python 增强建议书）的缩写，8 代表的是 Python 代码的样式指南。下面仅给大家列出 PEP 8 中初学者应严格遵守的一些编码规则：

1、不要在行尾添加分号，也不要用分号将两条命令放在同一行
2、通常情况下，在运算符两侧、函数参数之间以及逗号两侧，都建议使用空格进行分隔。
3、使用必要的空行可以增加代码的可读性，通常在顶级定义（如函数或类的定义）之间空两行，而方法定义之间空一行，另外在用于分隔某些功能的位置也可以空一行。

初学者，在写代码时，遇到代码中出现灰色波浪线，则点击黄色小灯泡，选择reformat the file，格式化即可。PEP484规范。

python基本数据类型

所谓的数据，其实就是需要保存到计算机进行存储的描述信息。因为数据的作用在使用过程中会有不同的使用方式或者具有不同的功能，所以python会对数据进行划分分类，也就是划分不同的类型。在编程中给不同的数据声明不同的类似，可以方便python解释器很好地去存储和调用这些数据。

int

int,integer：整数整型

在python中整数都属于整型，不同于其他语言，例如C语言会根据整数的大小将整型分类为short、int、long、long long 四种类型，python只有一种整型，即int类型，无论整型数字多大多小都属于int。

x = 10
print(x)
#type（变量名）表示查看这个变量的代表的数据类型
print(type(x))#<class 'int'>

y = 0
print(type(y)) # <class 'int'>

进制转换

• 整型数字之间的进制转换

#十进制，Decimal使用0-9这10个数字表达一个整数，满十进一
print(10)
print(122)
#二进制，Binary使用0，1这两个数字表达一个整数，满二进一
print(0b1010)# 打印的结果默认以十进制显示：10
#八进制octal使用0-7这八个数表达一个整数，满八进一
print(0o0777)# 打印的结果默认以十进制显示：511
#十六进制 hexadecimal使用0～9 a,b,c,d,e,f这十六的字符表达一个整数，满十六进一
print(0xffffff)# 打印的结果默认以十进制显示，16777215

#把其他进制的数字转换成二进制，例如把十进制的10转换为二进制
print(bin(10))#0b1010
#把其他进制的数字转换成十六进制，例如把十进制的19转换为十六进制
print(hex(19))#0x13
# 其他进制的数字转换成八进制，例如：把十进制的100转换
print(oct(100)) # 0o144

# 把其他的数字转换成十进制的

r = int("0b100", base=2)  # 这里就已经帮我们把二进制转换成十进制
print(r) # 4

r = int("0x5ff", base=16)print(r) # 1535
print(hex(1535)) # 0x5ff   #查看1535的十六进制数字

r = int("0o755", base=8) # 493
print(oct(r))  # 0o755  

float

在python中小数都属于浮点型（float）有两种表现形式

#小数点形式
f =  3.14
print(f)  # 3.14
print(type(f)) # <class 'float'>
#指数形式：aEn或aen
f = 3.14E5
print(f, type(f)) # 314000.0 <class 'float'>

f = 3E5
print(f, type(f)) # 300000.0 <class 'float'>

# E的后面跟着正数，则右边补0，3表示3个0
f = 3.1E3
print(f) # 3100

# E的后面跟着负数，则左边补0,-3表示3个0
f = 3.1E-3
print(f) # 0.0031

bool

布尔型(boolean)是一种数据类型，这种数据类型只有两个值，即真与假，在python中用bool表示不二类型，真用关键字true表示，有成立的意思，假用关键字false表示又不成立的意思

print(4 == 2) # False
print(5 > 1)  # True

name = "jiang"
print(name == "moluo") # False
print(1 == "1") # False

不光上面代码语句的结果是布尔值，单独一个数据没有进行计算也可以都有自己的布尔值，这就涉及到布尔的零值。

# 任意数据类型都一个具体值的布尔值为False,我们称为零值。该类型的其他值的布尔值皆为True。
print(bool("")) # 字符串的零值 “”
print(bool(0))  # 整型的零值 0

print(bool("0"))
print(bool("-1"))  
print(bool("moluo"))
print(bool(-1))
print(bool(0.1))

str

str,string，字符串，表示一串字符

• 字符串是由零个或多个字符组成的有限序列，字符的内容包含字母，标点，特殊符号，中文，日文等去哈世界的所有字符

• 在python中字符串是通过单引号’'或者双引号""标识的

• 强调：Python 字符串中的双引号和单引号没有任何区别！

#str字符串
##注意⚠️错误写法。： x = xiaoming
x = "xiaoming"  #正确写法# 只要不是用于计算的，仅仅用于记录的数据，都可以使用字符串来表示

mobile = '13928835901'
print(mobile, type(mobile)) # 13928835901 <class 'str'>

# 除非特殊情况，否则不要使用下面的方式声明字符串
message = """hello, xiaoming"""
print(message, type(message))

message2 = '''hello, xiaohong'''
print(message2, type(message2))

字符串的转义符

转义字符	说明
\n	换行符，将光标位置移到下一行开头。
\r	回车符，将光标位置移到本行开头。
\t	水平制表符，也即 Tab 键，一般相当于四个空格。
\b	退格（Backspace），将光标位置移到前一列（前一个字符）。
\\	反斜线
\'	单引号
\"	双引号
\	在字符串行尾的续行符，即一行未完，转到下一行继续写。

s1 = "woshi\nkiku"
print(s1) 
==>
woshi
kiku

长字符串

也叫文本字符串。就是三个单引号或者三个双引号圈住的内容，实际上也是字符串。

但是，开发中基本没有人这么写。开发中也不建议使用这样的字符串！！！因为长字符串作为注释了！！！！！

s = """
    s = "hi moluo\\nhi，python"
    I'm moluo
    这是一个python解释器路径："D:\\nythonProject\\nenv\Scripts\python.exe" 
长字符串中放置单引号或者双引号不会导致解析错误
"""
print(s)

username = input("your name:")
password = input("your password:")
# 格式化输出的字符串中存在多个变量，则需要在 % 后面把对应的变量使用小括号括起来。
print("name: %s , pw: %s", (username,password))
===>
your name:kiku
your password:123


name: %s , pw: %s ('kiku', '123')
year = 2022
month = 1
date = 7
# %02d 以整数输出，如果不足2位整数的，左边加0补充进去
print("%d-%02d-%02d" % (year, month, date))
year = 2022
month = 10
date = 17
print("%d-%02d-%02d" % (year, month, date))

在 print() 函数中，由引号包围的是格式化字符串，它相当于一个字符串模板，可以放置一些转换说明符（占位符）。本例的格式化字符串中包含一个%s和%d说明符，它最终会被后面的name和age 变量的值所替代。中间的%是一个分隔符，它前面是格式化字符串，后面是要输出的表达式。

print() 函数使用以%开头的转换说明符对各种类型的数据进行格式化输出，具体请看下表。

转换说明符	解释
%d、%i	转换为带符号的十进制整数
%o	转换为带符号的八进制整数
%x、%X	转换为带符号的十六进制整数
%e	转化为科学计数法表示的浮点数（e 小写）
%E	转化为科学计数法表示的浮点数（E 大写）
%f、%F	转化为十进制浮点数
%g	智能选择使用 %f 或 %e 格式
%G	智能选择使用 %F 或 %E 格式
%c	格式化字符及其 ASCII 码
%r	使用 repr() 函数将表达式转换为字符串
%s	使用 str() 函数将表达式转换为字符串

python数据类型

str

序列操作

字符串属于序列类型，所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引、下标）访问它们。

s= "hello kiku"
    0123456789
#下标从0开始，从左往右，逐一递增。  
s= "hello kiku"
    -9-8.....-1
#Python 还支持索引值是负数，此类索引是从右向左计数，换句话说，从最后一个元素开始计数，从索引值 -1 开始，从右往左，逐一递减

索引取值

格式：序列类型数据[下标]

s = "hello moluo"
print(s[6]) # m
print(s[-10]) # e

切片操作

格式：序列类型数据[start : end : step]

s = "hello moluo"
print(s[1:4]) # ell  => 取索引1到索引3（左闭又开）
print(s[:4])  # hell => start缺省，默认从0取
print(s[1:])  # ello moluo  => end缺省，默认取到最后
print(s[1:-1]) # ello molu

print(s[6:9]) # mol
print(s[-4:-1]) # olu
print(s[-1:-4]) # 空
print(s[-1:-4:-1]) #oul  step为1：从左向右一个一个取。为-1 ，从右向左一个取

判断成员是否存在

判断存在：Python 中，可以使用 in 关键字检查某元素是否为序列的成员。

s = "hello moluo"
print("moluo" in s) # True

相加拼接与乘法叠加

支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。

使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果

s = "hello"+" moluo"
print(s) # hello moluo

s= "*"*10
print(s) # **********

解包

# 解包，也叫解构
# 表示把一个序列的数据，按成员数量拆分成对应数量的变量进行保存
# s = "hu"
# a1, a2 = s
# print(a1)
# print(a2) # a1.print tab键

# 如果成员的数量与等号左边的变量数量不等，则报错！！
# s = "www"
# a1, a2, a3, a4 = s
# print(a1, a2, a3)
# 值类型错误：没有足够的成员值来进行解包(等号左边希望是4个，结果等号右边只提供了3个)
# ValueError: not enough values to unpack (expected 4, got 3)

s = "www"
a1, a2 = s
print(a1, a2)
# 值类型错误：太多的成员值需要解包了(等号左边希望是2个)
# ValueError: too many values to unpack (expected 2)

字符串常用方法

• len：查看字符长度

name = 'kiku'
print(len(name))
==>
4

• 添加符号join

a = "myname"
b = "kiku"
c = "jiang"
f = '-'.join((a,b,c))
print(f)

===>
myname-kiku-jiang

• 添加文字format

1.格式化小数长度表达：":.2f"
2.将小数按百分比形式显示：":.2%"
##按顺序填写
info = "你好,我叫{},今年{}了,我是{}."
print(info.format("kiku","25","student"))
===>
你好,我叫kiku,今年25了,我是student.

##自定义顺序
info = "你好,我叫{2},今年{1}了,我是{0}."
print(info.format("kiku","25","student"))
===>
你好,我叫student,今年25了,我是kiku.

##另一种表达发
name = 'kiku'
age = '22'
s1 = '我的名字叫{},我的年龄是{}'
print(s1.format(name,age))
#F大小写都可以做在版本3.6以上 以下写小写
s2 = F'我的名字叫{name},我的年龄是{age}'
print(s2)
==》
我的名字叫kiku,我的年龄是22
我的名字叫kiku,我的年龄是22

• 查找元素位置find

查找字符字符串片段在字符串中的下标位置，从前往后找，返回的是第一个被找到的字符串片段起始位置，
第一个参数：要查找的字符片段
第二个参数：要查找的起始点
第三个参数：要找到终止的的位置
如果查找的字符串存在多个，查找的结果是第一个出现的字符串下标
找不到就返回-1

#找出现的o的下标
s = "pythonisgood"
print("下标位置为",s.find("o"))
#找下标5-10之间的
print("下标位置为",s.find("o",5,10))
#找不到a
print("下标位置为",s.find("a"))
==>
下标位置为 4
下标位置为 9
下标位置为 -1

• 统计元素count

统计字符串片段，在字符串中出现次数
找不到返回0

s = "pythonisgood"
print("o出现的次数",s.count("o"))
print("a出现的次数",s.count("a"))
===>
o出现的次数 3
a出现的次数 0

• 替换指定的字符串片段replace

参数一：要替换的字符片段
参数二：替换之后的字符片段
参数三：替换次数，从前往后替换（默认替换所有）

s = "python to kiku"
res = s.replace('o','T')
print("默认替换位置",res)
res1 =  s.replace('o','T',1)
print("只替换一次",res1)
===>
默认替换位置 pythTn tT kiku
只替换一次 pythTn to kiku

• upper将小写字母转换为大写，
• lower将大写字母转换为小写,

#当前字符串中如果有大写不受影响，小写也同理

s = "python to kiku"
s1 = "PYTHON TO KIKU"
print("转为大写",s.upper())
print("转为小写",s1.lower())
===>
转为大写 PYTHON TO KIKU
转为小写 python to kiku

• split：制定分割点进行分割

参数一：分割点
参数二：分割的次数，默认为所有
s1 = "11111kasjd32435a45444"
print("以字母a进行分割列表默认分割",s1.split('a'))
print("以字母a进行分割列表分割1次",s1.split('a',1))
==>
s1 = "11111kasjd32435a45444"
print("以字母a进行分割列表默认分割",s1.split('a'))
print("以字母a进行分割列表分割1次",s1.split('a',1))

• strip：去除字符串首尾的空格

s = "         kuku      "
print("去除首尾空格",s.strip())
k = "66666kiku66666"
print("去除首尾6",k.strip('6'))
===>
去除首尾空格 kuku
去除首尾6 kiku

list

list列表，实际开发中，经常需要将一组（不止一个）数据存储起来，以便后边的代码使用，列表就是正阳的一个数据结构

变量 = [element1, element2, element3, ..., elementn]

注意：不同于C，java等语言的数组（Array），python的列表可以存放不同的，任意的数据类型对象。

列表声明

data = []
print(data,type(data))

data = [123,"kiku",Ture]
print(data,type(data))

序列操作

列表是 Python 序列的一种，我们可以使用索引（Index）访问列表中的某个元素（成员，得到的是一个元素的值），也可以使用切片访问列表中的一组元素（得到的是一个新的子列表）。

列表的索引与字符串一样，支持正数索引，从0开始，从左往右，逐一递增。也支持负数索引，从-1开始，从右往左，逐一递减。

索引取值

# 修改列表指定索引的值
data = ["xiaoming", "xiaohong"]
data[1] = "小红"
print(data)

# 取值
l = [10,11,12,13,14]
print(l[2]) # 12
print(l[-1]) # 14

切片操作

"""
列表的切片操作与字符串一样，左闭右开原则，也有3个选项：
变量[开始下标:结束下标:步进值]
列表的步进值默认是1，所以切片操作的方向默认从左往右的。
结果是一个列表，如果有适用范围，则结果包含范围内的指定成员，如果超出范围，则返回一个没有成员的空列表
"""
l = [10, 11, 12, 13, 14]
print(l[2:5])  # [12, 13, 14]
print(l[-3:-1])  # [12,13]
print(l[:3])  # [10,11,12]
print(l[1:])  # [11, 12, 13, 14]
print(l[:])   # [10, 11, 12, 13, 14]
print(l[-1:-3])  # []
print(l[-1:-3:-1])  # [14, 13]
print(l[::2])  # [10, 12, 14 ]

1、取出的元素数量为：结束位置 - 开始位置；

2、取出元素不包含结束位置对应的索引，列表最后一个元素使用 list[-1] 获取；

3、当缺省开始位置时，表示从连续区域开头到结束位置；

4、当缺省结束位置时，表示从开始位置到整个连续区域末尾；

5、两者同时缺省时，与列表本身等效；

6、step步进值为正，从左向右切，为负从右向左切。

判断成员是否存在

in 关键字检查某元素是否为序列的成员

l = [10,11,12,13,14]
print(20 in l) # False
print(12 in l) # True

相加拼接与乘法叠加

l1 = [1,2,3]
l2 = [4,5,6]
print(l1+l2) # [1, 2, 3, 4, 5, 6]

print(l2*3) # [4, 5, 6, 4, 5, 6, 4, 5, 6]

解包

a,b = [1,2]
print(a) # 1
print(b) # 2

tuple

tuple，元祖

python元祖与列表类似，不同之处在于元祖只能读，通常情况下，元祖用于保存无需修改的内容

元组使用小括号表示，声明一个元组：

(element1, element2, element3, ..., elementn)

注意：当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号（,）。否则 Python 解释器会将它视为字符串。

data = (1,2,3)
print(data,type(data)) # (1, 2, 3) <class 'tuple'>

data = 1, # 当元组声明时，可以省略小括号

常用操作

和列表一样，元组也是一种序列类型，因此也支持索引取值和切片操作、判断成员是否存在，解包。

l = (1,2,3,4,5)
# 索引取值
print(l[2]) # 3
print(l[-2]) # 4

# 切片操作
print(l[2:4]) # (3, 4)
print(l[:4]) # (1, 2, 3, 4)

# 判断成员是否存在
print(2 in l) # True

# 加法拼接
a = (1,2)
b = (4,5)
print(a+b) # (1, 2, 4, 5)

# 乘法叠加
print(b*3) # (4, 5, 4, 5, 4, 5)

# 解包
x, y = (10, 20)
print(x)  # 10
print(y)  # 20

# 组包
x = 1
y = 2
data = x,y
print(data) # (1, 2)

# 交换2个变量的值
x = 10
y = 20
# y, x = (x, y)
x,y = y,x
print(x,y) # 20 10

set

Python 中的集合(set)，和数学中的集合概念一样。由不同的可hash的不重复的元素组成的集合。
集合是无序的，集合中的元素是唯一的，集合一般用于元组或者列表中的元素去重，集合中默认去重。
     创建集合
         1、变量名=set(元素)  字符串/列表/元祖/字典
         2、变量名={元素，元素，，，}   元祖/字符串/数字
         3、元素是唯一的,用于列表的去重

声明集合

Python 集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔，如下所示：

{element1,element2,...}

其中，elementn 表示集合中的元素，个数没有限制。

从内容上看，同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型，否则 Python 解释器会抛出 TypeError 错误。

由于集合中的元素是无序的，因此无法向列表那样使用下标访问元素。Python 中，访问集合元素最常用的方法是使用循环结构，将集合中的数据逐一读取出来。

集合应用

关键字del：删除

a = [1,2,3]
#在计算机内存中a变量定义的列表删除
del a 
print(a)
#在计算机中删除中的值
del a[1]
print(a)
==>
[1, 3]

应用append函数

用于向列表末尾添加元素
a = [1,2,3]
a.append(4)
print(a)
==>
[1, 2, 3, 4]

添加元素

• add

     add(参数)往集合中添加元素 数字/字符串/元祖
     参数：添加的元素
a = {"a","b","c",23}
a.add(38732)
print(a)
===>
{38732, 'b', 'a', 'c', 23}

• update

     update(参数)可以将集合合并，随机排列
     参数：要合并的集合
a = {"a","b","c",23}
b = {123,938,"ju",(1,2),"[1, 3]"}
a.update(b)
print(a)
==>
{(1, 2), 938, 'ju', '[1, 3]', 'b', 'c', 23, 'a', 123}

删除元素

• pop

     pop(参数) 随机删除集合中的元素 如果集合没有元素，程序报错
     参数：要随机删除的集合
a = {"a","b","c","d","w"}
##pop不能指定删除的元素
b = a.pop()
print(b)
===>重复执行的结果
python3 /pythonfile/20221031.py
c
python3 /pythonfile/20221031.py
b

• remove

     remove(参数) 如果集合中有改元素则直接删除，如果没有，程序报错
     参数：要删除的元素
b = {123,938,"ju",(1,2),"[1, 3]"}
b.remove(123)
print(b)
===>
{(1, 2), 'ju', '[1, 3]', 938}

• discard

     discard(参数) 如果元素存在直接删除 如果元素不存在不不会报错
     参数：要删除的元素
    

集合的交集和并集

     交集
         使用 "&" 符号连接多个集合，得到相同的元素
     并集
         使用"|"符合连接多个集合，得到集合中的全部数据
a = {1,2,3}
b = {3,4,5}
print(a|b)
print(a&b)     
        

dict

dictionary，字典

声明字典

python使用 { } 创建字典，由于字典中每个元素都包含键（key）和值（value）两部分，因此在创建字典时，键和值之间使用冒号`:`分隔，相邻元素之间使用逗号`,`分隔，所有元素放在大括号`{ }`中。

使用`{ }`创建字典的语法格式如下：
dictname = {'key':'value1', 'key2':'value2', ...}

1、同一字典中的各个键必须唯一，不能重复。重复就覆盖了

2、低版本python解释器中，字典的键值对是无序的，但在3.6版本后字典的键值对默认有序的了，这是新的版本特征。

常用操作

book = {
    "price": 9.9,
    "title": "西游记后传",
    "publish": "人民出版社",
    "authors": ["吴承恩", "小明"]
}

# (1) 查键值
print(book["title"])  # 返回字符串 西游记后传
print(book["authors"])  # 返回列表 ["吴承恩", "小明"]

# (2) 添加或修改键值对，注意：如果键存在，则是修改，否则是添加
book["price"] = 299  # 修改键的值
book["publish"] = "北京商务出版社"  # 添加键值对

# (3) 删除键值对 del 删除命令
print(book)
del book["publish"]
print(book)
del book
print(book)

# (4) 判断键是否存在某字典中
print("price" in book)

#(5)从字典中获取指定的键值get
book = {
    "price": 9.9,
    "title": "西游记后传",
    "publish": "人民出版社",
    "authors": ["吴承恩", "小明"]
}
print(book.get("price"))
===>
9.9

将字典以列表形式显示

# keys函数
     keys(参数)将以列表的形式返回字典中的 所有键
     参数：
     
#items函数
     items(参数)将以列表的形式返回字典中的所有键 值对
     参数：
     
#values函数
     values(参数)将以列表的形式返回字典中的所有 值
     参数：
book = {
    "price": 9.9,
    "title": "西游记后传",
    "publish": "人民出版社",
    "authors": ["吴承恩", "小明"]
}
print(book.keys())
print(book.items())
print(book.values())
===>
dict_keys(['price', 'title', 'publish', 'authors'])
dict_items([('price', 9.9), ('title', '西游记后传'), ('publish', '人民出版社'), ('authors', ['吴承恩', '小明'])])
dict_values([9.9, '西游记后传', '人民出版社', ['吴承恩', '小明']])

将字典清空clear

     clear函数
     clear(参数)用于将字典清空
     参数：字典名
book = {
    "price": 9.9,
    "title": "西游记后传",
    "authors": ["吴承恩", "小明"]
}
book.clear()
print(book)
==>
{}

copy创建字典副本

     copy函数
     copy(参数)用于创建字典的副本，修改原字典对象，不会影响其副本。
     参数：要复制的字典名
book = {
    "price": 9.9,
    "title": "西游记后传",
    "authors": ["吴承恩", "小明"]
}
book2 = book.copy()
print(book2)      

fromkeys创建一个新的字典

     fromkeys函数
     fromkeys（参数1,参数2）用于创建一个新的字典，
     参数1：是一个序列(列表/元祖/集合)，用于作为字典的键。:
     参数2：可以是任何数据类型，作为每个键的值。
b = {"id":1}
a = b.fromkeys(("name","age"),("kiku",23))
print(a)
{'name': ('kiku', 23), 'age': ('kiku', 23)}

pop字典中移除指定键

     pop函数
     pop（参数）用于从字典中移除指定键，并返回该键所对应的值
     参数：要移除的键
 d = {
     "名字":"kiku",
     "年龄":18
 }
 r = d.pop('名字')
 print(r)
 print(d)
===>
 kiku
 {'年龄': 18}    

popitem 从字典中删除最后一项

     popitem函数
     popitem(参数)用于从字典中删除最后一项，并以元组形式返回该项所对应的键和值
     参数：要移除的键的字典名

update 将字典2的值更新到字典1

字典的操作方法:
     update函数
     update(参数)用于将字典2的值更新到字典1
     参数：字典2
     若字典2的键在字典1已经存在，则对字典1进行修改；
     若不存在，则对字典1进行添加

可变与不可变类型

# 可以使用del关键字删除字典的成员(键值对)
 book = {
     "price": 9.9,
     "title": "西游记后传",
     "publish": "人民出版社",
     "authors": ["吴承恩", "小明"],
 }

 del book["authors"]

 print(book)  # {'price': 9.9, 'title': '西游记后传', 'publish': '人民出版社'}

# 字符串就是一种只读类型的数据，不能修改/删除成员，很明显不能使用del
 s = "hello"
 del s[1]
 print(s)

# 列表可以删除/修改一个成员的值，但是基本不适用del来完成这个操作
 l = [1,2,3]
 del l[-1]
 print(l)

# 元组是只读类型的数据，所以不能删除/修改成员
 t = (1,2,3)
 del t[-1]
 print(t)

# 集合，可以删除/添加成员，但是没有下标，自然也就谈不上del删除成员了
s = {1, 2, 3, 4}
ret = s.pop()  # 删除第一个成员
print(ret, s)

# 从上面的操作的结果可以按成员是否可以修改，把数据类型进行分类了：
# 可变类型：list, dict, set
# 不可变类型：int, float, bool, str, tuple

关于数据类型的一些术语

基本类型
    int
    float
    bool
    str
容器类型，也叫复合类型
    list
    tuple
    set
    dict
序列类型
    str
    list
    tuple

变量缓存机制

缓存，就是暂时保存数据的一种技术，一般般我们把数据历史保存在内存中，缓存的数据会在特定时间后，或者特定条件后被删除

在计算机的硬件当中，内存是最重要的配置之一，直接关系到程序的运行速度和流畅度。而python代码的运行，肯定也是放在内存中运行的，所以官方实现了一套变量缓存机制，以达到节省内存的目的。在这个变量缓存机制中，python把一些相同值的变量在内存中指向同一块内存空间，而不再重新开辟新的空间。当然，变量缓存机制，也叫内存驻留机制。

python中使用id()函数查看数据的内存地址。

a = 10
b = 10
print(id(a)) # 140724467271616
print(id(b)) # 140724467271616

# 数值类型(int, float, bool)
1.对于整型而言，-5~正无穷范围内的相同值 id一致
2.对于浮点数而言，正数范围内的相同值 id一致
3.布尔值而言,值相同情况下，id一致
4.字符串值相同，id一致

# 容器类型(list, set, dict, tuple)
5.空元组 相同的情况下，地址相同
6.列表，元组，字典，集合无论什么情况 id标识都不同 

特别说明：简单元组，超出范围的整型，浮点型，在pycharm中因为是基于文本模式，所以会被当成一个整体在python解释器中被缓存，但是在黑窗口下因为是基于交互模式，因此一行代码就是一个整体，因此不会被缓存。

小数据池

不同的python文件（模块）中的代码里面的相同数据的本应该是不在同一个内存地址当中的， 而是应该全新的开辟一个新空间，但是这样也会占用了更多的内存，所以python定义了小数据池的概念，默认允许小部分数据即使在不同的文件当中，只要数据相同就可以使用同一个内存空间，以达到节省内存的目的。

小数据池只针对：int、bool、None关键字 ，这些数据类型有效。(int有争议，在部分系统下没有被缓存到小数据池中)

None属于python里面一个关键字，表示什么都没有，一般在程序中，用于表示没有结果。

A.py，代码：

a = 5
print(a, id(a))

B.py，代码：

# 在其他语言中，如果不同文件/不同窗口下，创建的变量的数据即便一样，也是保存不同的内存空间中的。
# 但是，python为了达到优化的目的，会把简单的小数据(整型，浮点型，None， bool)固话在一个相同内存中，所以python不同文件的小数据，内存地址是一样的。
a = 5
print(a, id(a))

is运算符

# 在python中如果要比较两个变量是否同一个值，一般是使用 == 判断。
# 但是，如果在判断的基础上，还要判断两个变量的内存地址是否一样的话，则需要使用is来判断
# 在python单纯依靠 == 判断两个数据，只能判断值是否一致
# 如果要判断数据是否是同一个，那么还要判断内存地址是否一样

a = 10
b = 10
print(a == b)# 文本模式下True，交互模式下False
# 除了上面直接使用id函数提取内存地址判断以外，可以使用is运算符来判断值是否一样，内存地址是否一样
print(a is b)
c = [1,2]
d = [1,2]
print(c is d)
===>>>>
True
True
False

数据类型转换

因为在工作中有时候数据的本身来源有可能是文件，内存，或者用户输入，所以不可避免的出现一些数据的类型与我们期望的不一样。

num = input("num:")
unit = input("unit:")
# 此时，就需要把用户录入的数据进行字符串类型转换成数值类型
num1 = int(num)
unit1 = float(unit)
print(type(num),type(unit))
print(type(num1),type(unit1))
=====>
num:4
unit:5
<class 'str'> <class 'str'>
<class 'int'> <class 'float'>

类型自动转换

自动转换，也叫隐式转换，是属于动态编程语言里面的一种特性。

动态编程语言：python，php，javascript

静态编程语言：java，go，C/C++

所谓的自动转换，实际上就是python解释器在遇到运算符需要进行运算符的，因为当前运算符的运行规则要求，则自动把参与运算的数据进行类型转换。

# data = bool + int
data = True + 2
print(data)


# data = bool + float
data = True + 3.14
print(data)

# data = int + float
data = 3 + 3.5
print(data)

类型强制转换

# 纯数字组成的字符串才能转成整型
i = int("3")
print(i,type(i)) # 3 <class 'int'>

# 小数转换成字符串
s = str(3.14)
print(s,type(s)) # 3.14 <class 'str'>

# 布尔值转换成整型
x = int(True)
print(x, type(x)) # 1 <class 'int'>

y = bool(0)
print(y, type(y)) # False <class 'bool'>

a = float(True)
print(a, type(a)) # 1.0 <class 'float'>

a = float("3.15")
print(a, type(a)) # 3.15 <class 'float'>

# # 以下错误示例：
# a = float("3.15元")
# print(a, type(a)) # ValueError: could not convert string to float: '3.15元'

容器类型数据强制类型转换

# 列表可以通过转换数据类型为集合，可以去除重复的成员
data = [1,3,4, 5, 3, 2, 1]
print(data, type(data))  # [1, 3, 4, 5, 3, 2, 1] <class 'list'>

ret = set(data)
print(ret, type(ret))  # {1, 2, 3, 4, 5} <class 'set'>

data = list(ret)
print(data, type(data)) # [1, 2, 3, 4, 5] <class 'list'>

# 字典转列表，可以直接提取字典的所有key出来
data = {"A":1, "B":2}
ret = list(data)
print(ret) # ['A', 'B']


# 元组可以通过转换数据成列表，修改成员的排列位置
old_data = (1, 2, 3, 4)
data = list(old_data)
data[1], data[2] = data[2], data[1]
new_data = tuple(data)
print(new_data) # (1, 3, 2, 4)