admin管理员组

文章数量:1026989

python基础第三章

•程序的格式框架

python代码缩进

1.缩进：一行代码开始前的空白区域，表达程序的格式框架。

2.缩进分为单层缩进和多层缩进

3.Python对缩进有着强制性要求，通过缩进来控制程序的结构和层次

缩进表达程序的格式框架

4.严格明确：缩进是语法的一部分，缩进不正确Python程序运行报错

5.所属关系：表达代码间包含和层次关系的唯一手段

6.长度一致：程序内一致即可，一般用4个空格或1个TAB（一般使用前者）

Java：
        if{}

        else{}
python
                if条件:
         缩进

---

注释

#红色标注为注释内容

# python 中多行注释使用三个单引号('')或三个双引号("")

---

 •数据类型

变量：程序中用于保存和表示数据的占位符号

变量：程序中用于保存和表示数据的占位符号

用来保存和表示数据的占位符号

•变量采用标识符(名字) 来表示，关联标识符的过程叫命名 

 TempStr 是变量名字 

•可以使用等号(=)向变量赋值或修改值，=被称为赋值符号 

 TempStr = “82F” #向变量 TempStr 赋值"82F"

---

命名

关联标识符的过程就是命名
命名规则: 大小写字母、数字、下划线等字符及组合 。
    如: TempStr,  Python_Great,  some1
 注意事项: 大小写敏感、首字符不能是数字、不与保留字相同 
    Python和python是不同变量，123Python是不合法的
 

---

变量命名方式

普通变量：全小写字母，单词之间用下划线分割，如my_var；

全局常量：全大写字母，单词之间用下划线分割，如MY_CONST；

类名：首字母大写，单词直接连在一起，采用驼峰命名法，如MyClass；

普通函数：与普通变量一样，如my_function()；

模块名：全小写字母，不使用下划线。

---

保留字

被编程语言内部定义并保留使用的标识符
Python语言有33个保留字(也叫关键字)
    if, elif, else, in ……（后续的学习中，我们会逐一使用他们）
保留字是编程语言的基本单词，大小写敏感 
    if 是保留字，If 是变量

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

---

 基本数据类型

数据类型	示例	数据类型	示例
整型	100	列表	["fdsg",645,45.2,2.11]
浮点型	5.23	元组	["fdsg",645,45.2,2.11]
复数型	2+3j	集合	{"name","sex","phone","qq"}
字符串型	"hello word"
布尔型	True  ,False	字典	{'jiuyue':'18','xiaohan':'nv','jingjiu':'tianjian'}

---

 整数型：

在Python3里，只有一种整发资型int，没有Pthon2中的 Long,因比整型是没有限制大小的。

可以当作 Long 类型使用。包括自然数和负整数。 

---

浮点型：

浮点数是一种对实数的近似表示，本身存在一定的误差。Python显示的结果是该浮点数在内存中的表示，因为二进制对很多浮点数无法准确表示只能用一个近似值代替。

浮点数可以采用科学计数法表示
使用字母e或E作为幂的符号，以10为基数，格式如下：
<a>e<b>表示a*10b
例如：4.3e-3值为0.00434.3*10-3
3.4e83.4*108
9.6E5值为960000.09.6*105

---

复数型：

复数型（Complex）是表示复數的类型，定义时Python 使用字母j来表示复数的虚部，我们可以观察到复数的实部和虚部分别为：

>>>  a  =1+2j
>>>   a.real  实部

1.0

>>>    a.imag   虚部

2.0

虽然定义a时实部和虛部使用的是整型数字，但复数型存儲的实部和虚部都是浮点型。

---

布尔型：

 布尔型（Boolean)Python中布尔值使用常量True 和False 来表示

布尔型变量可以使用比较表达式得到，同时，在数值上下文环境中，True 被当作 1，Falke被当作0。

>>> 1 >2

False

>>> 3< 5

>>> True+2

3

>>> false + 1

1

---

整数4种进制表示形式

十进制：1010,99,-217
二进制，以0b或0B开头：0b010,-0B101
Byte
八进制，以0o或0O开头：0o123,-0O456
十六进制，以0x或0X开头：0x9a,-0X89

最终是以十进制进行输出

---

字符串：

字符串：由0个或多个字符组成的有序字符序列

 字符串的生成:由一对单引号或一对双引号来生成字符串

操作符和使用方法	描述
”hello“ + ”word“	连接两个字符串
”hello“  *  n	复制n次字符串
"hello "  in  "helloworfd"	如果hello是hello word的子集，返回true否返false

---

 •语句与函数

常用函数

# len() 获取字符串的长度

str01 = ("九九九九九九九")  
print(len(str01)) 
#查看长度

---

# str() 把任意数据类型转换成string

​
int01 = 30
print(type(int01))
str02 = str(int01)
print(type(str02))
#Type()输出数据类型的​

---

#hex() 十进制转换成十六进制(0x)

print(hex(100))

---

#oct() 十进制转换成八进制(0o)

print(oct(56))

---

#chr() 十进制转换成字符

print(chr(45))

---

 #ord() 字符转换成十进制

print(ord('ABCD'))

---

函数及使用	描述
len(x)	获取字符串的长度 len("一二三456")结果为6
str(x)	任意类型x 所对应的字符串形式 str(1.56)结果为"1.56"  str([1,2])结果为"[1,2]"
hex(x)或oct(x)	整数x的十六进制或八进制小写形式字符串 hex(456)结果为"0x1a9" oct(425)结果为"0o651"
chr(u)	u为Unicode编码，返回其对应的字符
ord(x)	x为字符，返回其对应的Unicode编码

---

•方法形式提供的字符串处理功能

方法本身也是函数，但与<a>有关，<a>.<b>()风格使用

方法是一个特殊的函数

方法vs 函数

1.函数--->函数名字()       方法  类/模块.

2.方法名字()方法是一个特殊的函数

---

# str.lower()  把字符串转换成小写  返回字符串

a = "ABCDEFG"
print(a.lower())

---

#str.upper()  把字符串转换成大写  返回字符串

b = "jiujiujiu"
print(b.upper())

---

 #str.split(按照什么拆分)  拆分 返回的是list列表[]

c = "i love you"
print(c.split(" "))

---

#str.count(子串)  某一个子串在str(字符串)中出现的次数  返回值整数类型

d = "j"
#o在I,love,you中出现了多少次  3
print(b.count(d))
print(type(b.count(d)))
#<class 'int'>

---

#str.replace(old,new)  str中的任意一个子串替换成新的子串  返回字符串

str1 = "I,LOVE,YOU,JIUJIU"
str2 = str1.replace("JIUJIU","静九")
print(str2)

---

 #str.center(宽度,新的字符)  Str字符串根据某一个宽度进行居中 返回值字符串

宽度 = 新的字符+str 

新的字符必须是一个字符

str3 = "静九"
str4 = str3.center(10)
print(str4)
str5 = str3.center(10,"棒")
print(str5)

---

#str.strip(字符) 去掉左右两边的字符 返回字符串

str6 ="--I,LOVE,YOU--"
str7 = str6.strip("-L")
print(str7)

---

方法及使用	描述
str.lower()或str.upper()	返回字符串的副本，全部字符小写/大写 "GSGgfdfggsf".lower() 结果为"gsggfggsf"
str.split(sep=None)	返回一个列表，由str根据sep被分隔的部分组成 "A,B,C".split(",") 结果为['A','B','C']
str.count(sub)	返回子串sub在str中出现的次数 ”a apple a day".count("a')  结果为4
str.replace(old,new)	返回字符串str副本，所有old子串被替换为new "python".replace("n","n123.io")  结果为 "python123.io"
str.center(width[,fillchar])	字符串str根据宽度width进行居中,fillchar可选 “python”.center(20,"=")  结果为'=======python======='
str.strip(chars)	从str中去掉其左侧和右侧chars中列出的字符 "=python=".strip("=np") 结果为 "ytho'
str.join(iter)	在iter变量除最后元素外每个元素增加一个str ",".join("12345")  结果为"1,2,3,4,5" #主要用于字符串分割等

---

转义字符

1.转义符形成一些组合，表达一些不可打印的含义

"\b"回退 

"\n"换行(光标移动到下行首) 

"\r" 回车(光标移动到本行

2.可以去掉特殊含义

# 让这个双引号去掉本身含义，就打印双引号

print("我想\"嫁给\"老秦")

---

 格式化

第一种方式

• 使用百分号进行格式化输出的方式，用法如下：

        %s，表示字符串；

        %d，表示整数；

        %f，表示浮点数。

%代表一个占位符:

占位符必须和参数一一对应，否则，语句不通顺，报错

第二种

• ，用法如下：

        <模板字符串>.format(<逗号分隔的参数>)

第一种

  利用{}为占位符

第二种

  利用索引（索引是0）

100以上条数据，数数比较麻烦

第三种

  利用变量的赋值

大括号{}内部对格式化的配置方式 

{ <参数序号> ： <格式控制标记>}

 

大括号{}内部对格式化的配置方式 {<参数序号>: <格式控制标记>}
：	<填充>	<对齐>	<宽度>	<,>	<.精度>	<类型>
引导符号	用于填充单个字符	< 左对齐>右对齐^居中对齐	设定的输出宽度	数字的千位分隔符	浮点数小数精度或字符串最大输出长度	整数类型b,c,d,o,x,X浮点数类

参数序号：默认是0

填充字符：默认空格

如果是整数，在前面补空格，如果是字符串在后面补空格，

对齐方式：默认是左对齐

---

python运算符

算数运算符

是对运算数进行算术运算的一系列符号，能够满足一般的运算需求

算数运算符

运算符	描述	实例
+	加--两个对象相加	a+b输出结果  31
-	减--  得到负数或是一个数减去另一个数	a-b输出结果  11
*	乘--- 两个数相乘或是返回一个被重复若干次的字符串	a*b输出结果  210
/	除--  x  除以  y	a/b输出结果  2.1
%	取模 - 返回除法的余数	b%a输出结果  1
**	幂  -  返回除法的余数	a**b为10的21次方
//	取整除  -   向下取接近除数的整数	9//2，结果为4 -9//2，结果为-5

---

赋值运算符

赋值运算用于变量的赋值和更新，Python的赋值运算符除基础运算符外，还包括加法赋值运算符，减法赋值运算符等。

赋值运算符

运算符	描述	实例
=	简单的赋值运算符	c=a+b将a+b的值运算结果赋值给c
+=	加法赋值运算符	c+=a 等效于c=c+a
-=	减法赋值运算符	c-=a  等效于c=c-a
*=	乘法赋值运算符	c*=a 等效于 c=c*a
/=	除法赋值运算符	c/=a  等效于c=c/a
%=	取模赋值运算符	c%=a等效于  c=c%a
**=	幂赋值运算符	c**=a等效于  c=c**a
//=	取整除赋值运算符	c//=a等效于  c=c//a

---

关系运算符

关系运算符也称为比较运算符，用于对比数之间的大小或是否相等。

关系运算符

运算符	描述	实例
==	等于 - 比较对象是否相等	（a==b）返回 False
!=	不等于 -比较两个对象是否不相等	(a!=b）返回 Trrue
>	大于 - 返回X是否大于Y	(a>b）返回 False
<	小于 - 返回X是否小于Y，所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量True和false等价.	(a<b）返回 Trrue
>=	大于等于 - 返回X是否大于等于Y	(a>=b）返回 False
<=	小于等于 - 返回X是否小于等于Y	(a<=b）返回 Trrue

---

 逻辑运算符

逻辑运算即判断事物之间的“与”“或”“非”关系。

逻辑运算符

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与”-如果 x 为 False, x and y 返回 False，否则它返回 y的计算值。	(a and b)返回 False。
or	x or y	布尔”或”一如果 x 是True，它返回x的值，否则它返回y 的计算值。	(a or b)返回 True
not	not x	布尔“非”一如果 x 为 True，返回False 。如果 x 为 False，它返回True.	not(a and b)返回 True

---

 运算符优先级

Ppdhon中，运算符操作很常见，运算通常以表达式的形式进行。表达式由运算符和运算数组的成，比如“1+2”就是个表达式，其中的“+”是运算符。“1”和“2”则是运算数，一个表达式往往包含不止一个运算符，当一个表达式中存在多个运算符时，就需要运算的顺序，即运算特的优先级。

运算符	描述
**	指数(最高优先级)
~ + -	按位翻转，一元加号和减号(最后两个的方法名为+@和-@)
* / % //	乘，除，求余数和取整除
+ -	加法减法
>>  <<	右移，左移运算符
&	位’AND'
^ |	位运算符
<= <  > >=	比较运算符
== !=	等于运算符
=  %=  /=  //= -=  +=  *=  **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

---

数据结构

•  空列表 []

•  空元组 ()

•  空字典 {}

•  空集合 set()

List列表

列表是序列类型的一种扩展，十分常用

• 列表是一种序列类型，创建后可以随意被修改

• 使用方括号 [] 或list() 创建，元素间用逗号 , 分隔

• 列表中各元素类型可以不同，无长度限制

list01 = [1,2,3,4]#[] 空列表
#list() 里面什么都没有，创建空列表list02 = list() #[]
list03 = list(["张三","李四"])
print(list01)
print(list02)
print(list03)
list04 = [12.3,10,3.14e2,"张三"]
print(list04) #[12.3, 10, 314.0, '张三']

常用函数

#len(列表) 统计列表中元素的个数

#sum(列表) 求和

#max(列表) 最大值

#min(列表) 最小值

增

函数及使用	描述	举例	结果
list.insert(index，值)	根据下标插入数据	list.insert（1，8）	[1,2,3,4,5,6]
list.append(值)	直接在列表末尾添加上元素	list.append（10)	[1,8,2,3,4,5,6,10]

#创建
list01 = ["赵丽颖","迪丽热巴","黄明昊","白鹿","彭于晏"]#list.insert(index,值)  根据下标进行插入数据
list01.insert(1,"杨幂")
print(list01)  #['赵丽颖', '杨幂', '迪丽热巴', '黄明昊', '白鹿', '彭于晏']#list.append(值) 在末尾插入
list01.append("老吴")
print(list01) # ['赵丽颖', '杨幂', '迪丽热巴', '黄明昊', '白鹿', '彭于晏', '老吴']

删

#list.pop(index) 删除指定位置的数据

#list.remove(值) 删除值，但是他删除的是值第一次出现的位置

#list.clear() 删除所有数据

#创建
list01 = ["赵丽颖","迪丽热巴","黄明昊","老吴","白鹿","彭于晏","赵丽颖"]#list.pop(index) 删除指定位置的数据
list01.pop(3)
print(list01)  #['赵丽颖', '迪丽热巴', '黄明昊', '白鹿', '彭于晏', '赵丽颖']#list.remove(值) 删除值，但是他删除的是值第一次出现的位置
list01.remove("赵丽颖")
print(list01) #['迪丽热巴', '黄明昊', '白鹿', '彭于晏', '赵丽颖']#list.clear() 删除所有数据
list01.clear()
print(list01) #[]

改

#List[i] = 值（要修改的值）

#List[i] = 值（要修改的值）
#重新进行赋值
list01[3] = "杨幂"
print(list01)  #['赵丽颖', '迪丽热巴', '黄明昊', '杨幂', '白鹿', '彭于晏', '赵丽颖']

查
 

 查询单个值

   利用[index]进行查询 index-->从0开始

 查询多个值

   [start:stop]   左开右闭

   小数在前面

   正向递增  反向递减   一负一正

#创建list
list01 = [1,2,5,7,-2,-9]#查询所有 ---直接打印列表名字
print(list01)
print(list01[1])  #2
print(list01[1:4])  #[2, 5, 7]
print(list01[-5:-2]) #[2, 5, 7]
print(list01[-5:4]) #[2, 5, 7]

#list。reverse（列表）   反转

list02 = [1,2,3,4,5,6]
list02.reverse()
print(list02)  #[6,5,4,3,2,1]

#list。copy（）  拷贝

#list。copy（）  拷贝
list03 =list02.copy()
print(list03)

list.sort（reverse = ture/false）  排序 默认是升序

reverse = Ture 降序  reverse = False 升序

#list.sort（reverse = ture/false）  排序 默认是升序
#reverse = Ture 降序  reverse = False 升序list04 = [1,5,6,8,-9,3]
list04.sort()
print(list04) #[-9, 1, 3, 5, 6, 8]

元组tuple

元组是序列类型的一种扩展

元组是一种序列类型，一旦创建就不能被修改  不能增删改

#使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔

#使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔
#创建
tuple01 = (1,2,3)
tuple02 = tuple() #空元组  ()
tuple03 = tuple((5,6,7))
print(tuple01)
print(tuple02)
print(tuple03)

查

 查询所有值  直接打印元组名字

 查询单个值  [index]

 查询多个值  [start:stop] 左开右闭 一负一正 

#字符串只能存放一个值  元组可以存放多个值，加个逗号可以进行区分

tuple02 = (1,2,3,4,5,6)print(tuple02)
print(tuple02[2])
print(tuple02[1:4])
print(tuple02[-5:-2])
print(tuple02[-5:4])

#创建
Str = ("张三")
print(type(Str)) #<class 'str'>
#字符串只能存放一个值  元组可以存放多个值，加个逗号可以进行区分
tuple01 = ("张三",)
print(type(tuple01)) #<class 'tuple'>
#复制完以后把数据变成元组
print(tuple01*3)  #('张三', '张三', '张三')

#len(tuple)  计算元组元素个数

#max(tuple)  返回元组中元素最大值

#min(tuple)  返回元组中元素最小值

 集合set

集合是多个元素的无序(没有下标)组合

集合类型与数学中的集合概念一致

集合元素之间无序，每个元素唯一，不存在相同元素

集合元素不可更改，不能是可变数据类型    

 无序唯一

• 集合用大括号 {} 表示，元素间用逗号分隔

• 建立集合类型用 {} 或 set()

• 建立空集合类型，必须使用set()

  #创建
  set01 = {1,2,3,4,5}
  set02 = set() #set()
  set03 = set({9,10,11})
  print(set01)
  print(set02) 
  print(set03)
  print(type({})) #<class 'dict'>
  print(type(set())) #<class 'set'>

  增

set.add(数据) 添加一个数据 不也能添加已有的数据，虽然不报错，但是不显示

set01.update(set02) 批量添加数据
  把set02添加到zet01中

#创建
set01 = {"花木兰","貂蝉","妲己","王昭君"}#set.add(数据) 添加一个数据  不也能添加已有的数据，虽然不报错，但是不显示set01.add("杨玉环")
print(set01) #{'花木兰', '王昭君', '貂蝉', '妲己', '杨玉环'}
set01.add("花木兰")
print(set01) #{'花木兰', '杨玉环', '王昭君', '妲己', '貂蝉'}#set01.update(set02) 批量添加数据
#把set02添加到zet01中set02 = {"嬴政","武则天"}
set01.update(set02)
print(set01) #{'花木兰', '嬴政', '杨玉环', '妲己', '王昭君', '武则天', '貂蝉'}

差

直接打印集合名字去查询

不能使用索引进行查询，因为我们集合是无序的

print(set01)
print(set02) 
print(set03)

集合常用函数和方法

#set.copy() 复制/拷贝一个一模一样的集合

#len(set) 返回集合的元素个数，集合的长度

 x in set 元素x在不在集合当中
 x not in set 元素不在集合中

#set(x) 把其他数据类型（x）转换成集合类型

#创建
set01 = {"喜羊羊","美羊羊","懒洋洋","沸羊羊","暖羊羊","慢羊羊","灰太狼"}#set.copy() 复制/拷贝一个一模一样的集合
set02 = set01.copy()
print(set02) #{'慢羊羊', '美羊羊', '灰太狼', '喜羊羊', '沸羊羊', '暖羊羊', '懒洋洋'}#len(set) 返回集合的元素个数，集合的长度
a = len(set01)
print(a) #7#x in set 元素x在不在集合当中#x not in set 元素不在集合中print("慢羊羊" in set01) #True
print("慢羊羊" not in set01) #False#set(x) 把其他数据类型（x）转换成集合类型 
Str = "hello"
print(Str) #hello
print(type(Str))b = set(Str)
print(type(b)) #<class 'set'>
print(b) #{'o', 'e', 'h', 'l'}

并差交补，包含关系

 交集

1.交的符号  &

   2.两个的公共部分

 补集

  1.补集的符号 ^

  2.并集-交集 = 补集

  3.除去公共部分，set01和set02的单独部分我都要

 并集

   1.他的符号是  |

   2.返回两个集合的所有值

 差集

   1.差的符号是  -

   2.set01 - set02  set01去掉公共部分的值

包含关系

 判断set01 和 set02是不是包含关系

 >  <   >=  <=

 口朝向那边，那边是大的

  set01 >= set02   set01包含set02

#并
print(set01 | set02)
#差
print(set01 - set02) 
print(set02 - set01) 
#交
print(set01 & set02)
#补
print(set01 ^ set02)
#包含关系
print(set01 >= set02)
print(set01 < set02)print(set02 < set01) 

字典dict

•   映射是一种键(索引)和值(数据)的对应

• 键值对：键是数据索引的扩展

• 字典是键值对的集合，键值对之间无序(没有索引）

• 采用大括号{}和dict()创建，键值对用冒号: 表示

• 字典类型是“映射”的体现

• <字典变量> = {<键1>:<值1>, … , <键n>:<值n>}

• 增

    dict01[新的key] = 新的值  添加数据

  删

   dict.pop(key)  根据key删除一对数据

   dict.clear()  清除所有数据

  改

    只能修改值，不可以修改key

    为什么：因为key是唯一的，不能重复的，避免出现重复的情况所以不能修改

    怎么修改： 

        先根据key拿到值  dict01["孙策"]

        再重新赋值

  查

   查询单个值

    1.dict[key]  利用key查询value

    2.dict.get(key,默认值)  利用key查询value 如果key没有，那么就输出默认值

   查询所有值(包括key和value)

    1.直接打印字典名

    2.dict.items() 迭代方法

#创建
dict01 = {"张三":18,"李四":20,"王五":80}
dict02 = dict()
dict03 = dict({"张三":90,"李四":20})
print(dict01)  #{'张三': 18, '李四': 20, '王': 80}
print(dict02) #{}
print(dict03)  #{'张三': 90, '李四': 20}增dict01["小乔"] = "天魔缭乱"
print(dict01) 删dict01.pop("元哥")
print(dict01) 改dict01["孙策"] = "乘风破浪"
print(dict01) 查
#创建
dict01 = {"鲁班":"空中支援","花木兰":"切换形态","孙策":"开船","元哥":"无敌时间移位"}# dict.keys()  查看所有的key(英雄)
print(dict01.keys()) #dict_keys(['鲁班', '花木兰', '孙策', '元哥'])# dict.values()  查询所有的value(大招)
print(dict01.values()) #dict_values(['空中支援', '切换形态', '开船', '无敌时间移位'])print(dict01["花木兰"]) #切换形态
print(dict01.get("花木兰"))  #切换形态
print(dict01.get("貂蝉","没有此英雄，请购买")) #没有此英雄，请购买print(dict01) 
print(dict01.items()) #dict_items([('鲁班', '空中支援'), ('花木兰', '切换形态'), ('孙策', '开船'), ('元哥', '无敌时间移位')])

常用的函数和方法

 k in dict    key在不在字典里面

 如果在输出True  如果不在输出False

 为什么 20 in dict0

   原因是他只能判断key在不在，不能判断value在不在

 dict01.update(dict02)  把02中的数据更新到01中

 更新是更新多个数据

 是复制吗？ no

 但是你可以理解成添加数据

del 字典名[key]  删除指定位置的数据

  和pop一样 

  dict.pop(key) 删除指定位置的数据

print("张三" in dict01) 
print(20 in dict01) 
#创建字典
dict01 = {"张三":20,"王五":30,"赵六":70,"李四":80}
dict02 = {"翠花":20,"光头强":10}
dict01.update(dict02)
print(dict01) 
print(dict02) #创建字典
dict01 = {"张三":20,"王五":30,"赵六":70,"李四":80}
dict02 = {"翠花":20,"光头强":10}del dict01["李四"]
print(dict01)

函数

编程语言的函数都可以分为两类：内置函数和自定义函数。

内置函数分为

数字相关的内置函数

# abs(x) 求绝对值

  divmod(x,y)  (x//y)商和(x%y)余数，同时输出商和余数

   x//y  整除  向下取整

   x%y  余数=被除数-除数*商  10%-3=-2

  pow(x,y) 幂 x的y次方 -------x**y

  pow(x,y,z) 先求x的y次方  得到的结果和z进行取余----x**y%z

#round(x,f) 四舍五入保留小数

#max(x1,x2,..........,xn) 返回最大值

 int(x) 将x转换成整数，舍弃小数部分

   可以把字符串转成整数,但是你的字符串必须是数字字符串 比如"123"

 float(x) 将x转换成小数，增加小数部分

   可以把字符串变成小数,但是字符串必须是数字字符串 比如"123" "22.9"

 complex(x) 将x变成复数，增加虚数部分

   x可以是整数 、小数、数字类型的字符串

• 进制的转换：bin()，oct()和hex()函数

"""

•进制的转换：

 bin() 转换成二进制(0b) 返回一个字符串

 oct() 转换成八进制(0o)  返回一个字符串

 hex() 转换成十六进制(0x) 返回一个字符串

"""

  chr(x) 把十进制转换成ASCLL编码字符

  ord(x) 把ASCLL编码字符转换成十进制

  all(序列)  all()接受一个序列 

    当序列中所有的元素都计算为真时，返回True，否则为False

  []  ()  {}  set()都是Flase

 any(x)  any()则在序列中的任意一个元素为真时返回True，否则为False

 range(start,stop) 迭代对象的生成  返回的是一个迭代对象，并不是一个列表类型

   1.迭代对象不能打印，所以使用list()转换成列表

   2.左开右闭

range(start,stop,step)

   step 步长

print(abs(-10)) x = 10
y = 3
print(divmod(10,3)) print(pow(x,y)) #1000
print(pow(x,y,3)) #1
print(pow(2,5,10))print(round(3.1415926,4)) print(max(4,6,9,1,0,10))print(int(3.92)) 
print(int("123"))print(float(12)) 
print(float("22"))print(complex(10)) #(10+0j)
print(complex(3.14)) #(3.14+0j)
print(complex("4.56"))a = bin(100)
print(a) #0b1100100
print(type(a)) #<class 'str'>print(ord("∞")) #8734
print(chr(64)) #@"""all(序列)  all()接受一个序列 当序列中所有的元素都计算为真时，返回True，否则为False[]  ()  {}  set()都是Flase
"""
a = ["hello",3.14,4+3j,{"张三":18,"李四":20}]
print(all(a)) #True
b = ["hello",3.14,4+3j,{"张三":18,"李四":20},[]]
print(all(b)) #False"""any(x)  any()则在序列中的任意一个元素为真时返回True，否则为False
"""
c = [{},(),set()]
print(any(c)) #False
"""range(start,stop) 迭代对象的生成  返回的是一个迭代对象，并不是一个列表类型1.迭代对象不能打印，所以使用list()转换成列表2.左开右闭
range(start,stop,step)step 步长
"""a = range(1,10) #a是一个迭代对象
print(a) #range(1, 10)
#list(a) 把a转换成list列表 
print(list(a)) #[1, 2, 3, 4, 5, 6, 7, 8, 9]b = range(1,10,2)
print(list(b)) #[1, 3, 5, 7, 9]

python基础第三章

•程序的格式框架

python代码缩进

1.缩进：一行代码开始前的空白区域，表达程序的格式框架。

2.缩进分为单层缩进和多层缩进

3.Python对缩进有着强制性要求，通过缩进来控制程序的结构和层次

缩进表达程序的格式框架

4.严格明确：缩进是语法的一部分，缩进不正确Python程序运行报错

5.所属关系：表达代码间包含和层次关系的唯一手段

6.长度一致：程序内一致即可，一般用4个空格或1个TAB（一般使用前者）

Java：
        if{}

        else{}
python
                if条件:
         缩进

---

注释

#红色标注为注释内容

# python 中多行注释使用三个单引号('')或三个双引号("")

---

 •数据类型

变量：程序中用于保存和表示数据的占位符号

变量：程序中用于保存和表示数据的占位符号

用来保存和表示数据的占位符号

•变量采用标识符(名字) 来表示，关联标识符的过程叫命名 

 TempStr 是变量名字 

•可以使用等号(=)向变量赋值或修改值，=被称为赋值符号 

 TempStr = “82F” #向变量 TempStr 赋值"82F"

---

命名

关联标识符的过程就是命名
命名规则: 大小写字母、数字、下划线等字符及组合 。
    如: TempStr,  Python_Great,  some1
 注意事项: 大小写敏感、首字符不能是数字、不与保留字相同 
    Python和python是不同变量，123Python是不合法的
 

---

变量命名方式

普通变量：全小写字母，单词之间用下划线分割，如my_var；

全局常量：全大写字母，单词之间用下划线分割，如MY_CONST；

类名：首字母大写，单词直接连在一起，采用驼峰命名法，如MyClass；

普通函数：与普通变量一样，如my_function()；

模块名：全小写字母，不使用下划线。

---

保留字

被编程语言内部定义并保留使用的标识符
Python语言有33个保留字(也叫关键字)
    if, elif, else, in ……（后续的学习中，我们会逐一使用他们）
保留字是编程语言的基本单词，大小写敏感 
    if 是保留字，If 是变量

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

---

 基本数据类型

数据类型	示例	数据类型	示例
整型	100	列表	["fdsg",645,45.2,2.11]
浮点型	5.23	元组	["fdsg",645,45.2,2.11]
复数型	2+3j	集合	{"name","sex","phone","qq"}
字符串型	"hello word"
布尔型	True  ,False	字典	{'jiuyue':'18','xiaohan':'nv','jingjiu':'tianjian'}

---

 整数型：

在Python3里，只有一种整发资型int，没有Pthon2中的 Long,因比整型是没有限制大小的。

可以当作 Long 类型使用。包括自然数和负整数。 

---

浮点型：

浮点数是一种对实数的近似表示，本身存在一定的误差。Python显示的结果是该浮点数在内存中的表示，因为二进制对很多浮点数无法准确表示只能用一个近似值代替。

浮点数可以采用科学计数法表示
使用字母e或E作为幂的符号，以10为基数，格式如下：
<a>e<b>表示a*10b
例如：4.3e-3值为0.00434.3*10-3
3.4e83.4*108
9.6E5值为960000.09.6*105

---

复数型：

复数型（Complex）是表示复數的类型，定义时Python 使用字母j来表示复数的虚部，我们可以观察到复数的实部和虚部分别为：

>>>  a  =1+2j
>>>   a.real  实部

1.0

>>>    a.imag   虚部

2.0

虽然定义a时实部和虛部使用的是整型数字，但复数型存儲的实部和虚部都是浮点型。

---

布尔型：

 布尔型（Boolean)Python中布尔值使用常量True 和False 来表示

布尔型变量可以使用比较表达式得到，同时，在数值上下文环境中，True 被当作 1，Falke被当作0。

>>> 1 >2

False

>>> 3< 5

>>> True+2

3

>>> false + 1

1

---

整数4种进制表示形式

十进制：1010,99,-217
二进制，以0b或0B开头：0b010,-0B101
Byte
八进制，以0o或0O开头：0o123,-0O456
十六进制，以0x或0X开头：0x9a,-0X89

最终是以十进制进行输出

---

字符串：

字符串：由0个或多个字符组成的有序字符序列

 字符串的生成:由一对单引号或一对双引号来生成字符串

操作符和使用方法	描述
”hello“ + ”word“	连接两个字符串
”hello“  *  n	复制n次字符串
"hello "  in  "helloworfd"	如果hello是hello word的子集，返回true否返false

---

 •语句与函数

常用函数

# len() 获取字符串的长度

str01 = ("九九九九九九九")  
print(len(str01)) 
#查看长度

---

# str() 把任意数据类型转换成string

​
int01 = 30
print(type(int01))
str02 = str(int01)
print(type(str02))
#Type()输出数据类型的​

---

#hex() 十进制转换成十六进制(0x)

print(hex(100))

---

#oct() 十进制转换成八进制(0o)

print(oct(56))

---

#chr() 十进制转换成字符

print(chr(45))

---

 #ord() 字符转换成十进制

print(ord('ABCD'))

---

函数及使用	描述
len(x)	获取字符串的长度 len("一二三456")结果为6
str(x)	任意类型x 所对应的字符串形式 str(1.56)结果为"1.56"  str([1,2])结果为"[1,2]"
hex(x)或oct(x)	整数x的十六进制或八进制小写形式字符串 hex(456)结果为"0x1a9" oct(425)结果为"0o651"
chr(u)	u为Unicode编码，返回其对应的字符
ord(x)	x为字符，返回其对应的Unicode编码

---

•方法形式提供的字符串处理功能

方法本身也是函数，但与<a>有关，<a>.<b>()风格使用

方法是一个特殊的函数

方法vs 函数

1.函数--->函数名字()       方法  类/模块.

2.方法名字()方法是一个特殊的函数

---

# str.lower()  把字符串转换成小写  返回字符串

a = "ABCDEFG"
print(a.lower())

---

#str.upper()  把字符串转换成大写  返回字符串

b = "jiujiujiu"
print(b.upper())

---

 #str.split(按照什么拆分)  拆分 返回的是list列表[]

c = "i love you"
print(c.split(" "))

---

#str.count(子串)  某一个子串在str(字符串)中出现的次数  返回值整数类型

d = "j"
#o在I,love,you中出现了多少次  3
print(b.count(d))
print(type(b.count(d)))
#<class 'int'>

---

#str.replace(old,new)  str中的任意一个子串替换成新的子串  返回字符串

str1 = "I,LOVE,YOU,JIUJIU"
str2 = str1.replace("JIUJIU","静九")
print(str2)

---

 #str.center(宽度,新的字符)  Str字符串根据某一个宽度进行居中 返回值字符串

宽度 = 新的字符+str 

新的字符必须是一个字符

str3 = "静九"
str4 = str3.center(10)
print(str4)
str5 = str3.center(10,"棒")
print(str5)

---

#str.strip(字符) 去掉左右两边的字符 返回字符串

str6 ="--I,LOVE,YOU--"
str7 = str6.strip("-L")
print(str7)

---

方法及使用	描述
str.lower()或str.upper()	返回字符串的副本，全部字符小写/大写 "GSGgfdfggsf".lower() 结果为"gsggfggsf"
str.split(sep=None)	返回一个列表，由str根据sep被分隔的部分组成 "A,B,C".split(",") 结果为['A','B','C']
str.count(sub)	返回子串sub在str中出现的次数 ”a apple a day".count("a')  结果为4
str.replace(old,new)	返回字符串str副本，所有old子串被替换为new "python".replace("n","n123.io")  结果为 "python123.io"
str.center(width[,fillchar])	字符串str根据宽度width进行居中,fillchar可选 “python”.center(20,"=")  结果为'=======python======='
str.strip(chars)	从str中去掉其左侧和右侧chars中列出的字符 "=python=".strip("=np") 结果为 "ytho'
str.join(iter)	在iter变量除最后元素外每个元素增加一个str ",".join("12345")  结果为"1,2,3,4,5" #主要用于字符串分割等

---

转义字符

1.转义符形成一些组合，表达一些不可打印的含义

"\b"回退 

"\n"换行(光标移动到下行首) 

"\r" 回车(光标移动到本行

2.可以去掉特殊含义

# 让这个双引号去掉本身含义，就打印双引号

print("我想\"嫁给\"老秦")

---

 格式化

第一种方式

• 使用百分号进行格式化输出的方式，用法如下：

        %s，表示字符串；

        %d，表示整数；

        %f，表示浮点数。

%代表一个占位符:

占位符必须和参数一一对应，否则，语句不通顺，报错

第二种

• ，用法如下：

        <模板字符串>.format(<逗号分隔的参数>)

第一种

  利用{}为占位符

第二种

  利用索引（索引是0）

100以上条数据，数数比较麻烦

第三种

  利用变量的赋值

大括号{}内部对格式化的配置方式 

{ <参数序号> ： <格式控制标记>}

 

大括号{}内部对格式化的配置方式 {<参数序号>: <格式控制标记>}
：	<填充>	<对齐>	<宽度>	<,>	<.精度>	<类型>
引导符号	用于填充单个字符	< 左对齐>右对齐^居中对齐	设定的输出宽度	数字的千位分隔符	浮点数小数精度或字符串最大输出长度	整数类型b,c,d,o,x,X浮点数类

参数序号：默认是0

填充字符：默认空格

如果是整数，在前面补空格，如果是字符串在后面补空格，

对齐方式：默认是左对齐

---

python运算符

算数运算符

是对运算数进行算术运算的一系列符号，能够满足一般的运算需求

算数运算符

运算符	描述	实例
+	加--两个对象相加	a+b输出结果  31
-	减--  得到负数或是一个数减去另一个数	a-b输出结果  11
*	乘--- 两个数相乘或是返回一个被重复若干次的字符串	a*b输出结果  210
/	除--  x  除以  y	a/b输出结果  2.1
%	取模 - 返回除法的余数	b%a输出结果  1
**	幂  -  返回除法的余数	a**b为10的21次方
//	取整除  -   向下取接近除数的整数	9//2，结果为4 -9//2，结果为-5

---

赋值运算符

赋值运算用于变量的赋值和更新，Python的赋值运算符除基础运算符外，还包括加法赋值运算符，减法赋值运算符等。

赋值运算符

运算符	描述	实例
=	简单的赋值运算符	c=a+b将a+b的值运算结果赋值给c
+=	加法赋值运算符	c+=a 等效于c=c+a
-=	减法赋值运算符	c-=a  等效于c=c-a
*=	乘法赋值运算符	c*=a 等效于 c=c*a
/=	除法赋值运算符	c/=a  等效于c=c/a
%=	取模赋值运算符	c%=a等效于  c=c%a
**=	幂赋值运算符	c**=a等效于  c=c**a
//=	取整除赋值运算符	c//=a等效于  c=c//a

---

关系运算符

关系运算符也称为比较运算符，用于对比数之间的大小或是否相等。

关系运算符

运算符	描述	实例
==	等于 - 比较对象是否相等	（a==b）返回 False
!=	不等于 -比较两个对象是否不相等	(a!=b）返回 Trrue
>	大于 - 返回X是否大于Y	(a>b）返回 False
<	小于 - 返回X是否小于Y，所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量True和false等价.	(a<b）返回 Trrue
>=	大于等于 - 返回X是否大于等于Y	(a>=b）返回 False
<=	小于等于 - 返回X是否小于等于Y	(a<=b）返回 Trrue

---

 逻辑运算符

逻辑运算即判断事物之间的“与”“或”“非”关系。

逻辑运算符

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与”-如果 x 为 False, x and y 返回 False，否则它返回 y的计算值。	(a and b)返回 False。
or	x or y	布尔”或”一如果 x 是True，它返回x的值，否则它返回y 的计算值。	(a or b)返回 True
not	not x	布尔“非”一如果 x 为 True，返回False 。如果 x 为 False，它返回True.	not(a and b)返回 True

---

 运算符优先级

Ppdhon中，运算符操作很常见，运算通常以表达式的形式进行。表达式由运算符和运算数组的成，比如“1+2”就是个表达式，其中的“+”是运算符。“1”和“2”则是运算数，一个表达式往往包含不止一个运算符，当一个表达式中存在多个运算符时，就需要运算的顺序，即运算特的优先级。

运算符	描述
**	指数(最高优先级)
~ + -	按位翻转，一元加号和减号(最后两个的方法名为+@和-@)
* / % //	乘，除，求余数和取整除
+ -	加法减法
>>  <<	右移，左移运算符
&	位’AND'
^ |	位运算符
<= <  > >=	比较运算符
== !=	等于运算符
=  %=  /=  //= -=  +=  *=  **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

---

数据结构

•  空列表 []

•  空元组 ()

•  空字典 {}

•  空集合 set()

List列表

列表是序列类型的一种扩展，十分常用

• 列表是一种序列类型，创建后可以随意被修改

• 使用方括号 [] 或list() 创建，元素间用逗号 , 分隔

• 列表中各元素类型可以不同，无长度限制

list01 = [1,2,3,4]#[] 空列表
#list() 里面什么都没有，创建空列表list02 = list() #[]
list03 = list(["张三","李四"])
print(list01)
print(list02)
print(list03)
list04 = [12.3,10,3.14e2,"张三"]
print(list04) #[12.3, 10, 314.0, '张三']

常用函数

#len(列表) 统计列表中元素的个数

#sum(列表) 求和

#max(列表) 最大值

#min(列表) 最小值

增

函数及使用	描述	举例	结果
list.insert(index，值)	根据下标插入数据	list.insert（1，8）	[1,2,3,4,5,6]
list.append(值)	直接在列表末尾添加上元素	list.append（10)	[1,8,2,3,4,5,6,10]

#创建
list01 = ["赵丽颖","迪丽热巴","黄明昊","白鹿","彭于晏"]#list.insert(index,值)  根据下标进行插入数据
list01.insert(1,"杨幂")
print(list01)  #['赵丽颖', '杨幂', '迪丽热巴', '黄明昊', '白鹿', '彭于晏']#list.append(值) 在末尾插入
list01.append("老吴")
print(list01) # ['赵丽颖', '杨幂', '迪丽热巴', '黄明昊', '白鹿', '彭于晏', '老吴']

删

#list.pop(index) 删除指定位置的数据

#list.remove(值) 删除值，但是他删除的是值第一次出现的位置

#list.clear() 删除所有数据

#创建
list01 = ["赵丽颖","迪丽热巴","黄明昊","老吴","白鹿","彭于晏","赵丽颖"]#list.pop(index) 删除指定位置的数据
list01.pop(3)
print(list01)  #['赵丽颖', '迪丽热巴', '黄明昊', '白鹿', '彭于晏', '赵丽颖']#list.remove(值) 删除值，但是他删除的是值第一次出现的位置
list01.remove("赵丽颖")
print(list01) #['迪丽热巴', '黄明昊', '白鹿', '彭于晏', '赵丽颖']#list.clear() 删除所有数据
list01.clear()
print(list01) #[]

改

#List[i] = 值（要修改的值）

#List[i] = 值（要修改的值）
#重新进行赋值
list01[3] = "杨幂"
print(list01)  #['赵丽颖', '迪丽热巴', '黄明昊', '杨幂', '白鹿', '彭于晏', '赵丽颖']

查
 

 查询单个值

   利用[index]进行查询 index-->从0开始

 查询多个值

   [start:stop]   左开右闭

   小数在前面

   正向递增  反向递减   一负一正

#创建list
list01 = [1,2,5,7,-2,-9]#查询所有 ---直接打印列表名字
print(list01)
print(list01[1])  #2
print(list01[1:4])  #[2, 5, 7]
print(list01[-5:-2]) #[2, 5, 7]
print(list01[-5:4]) #[2, 5, 7]

#list。reverse（列表）   反转

list02 = [1,2,3,4,5,6]
list02.reverse()
print(list02)  #[6,5,4,3,2,1]

#list。copy（）  拷贝

#list。copy（）  拷贝
list03 =list02.copy()
print(list03)

list.sort（reverse = ture/false）  排序 默认是升序

reverse = Ture 降序  reverse = False 升序

#list.sort（reverse = ture/false）  排序 默认是升序
#reverse = Ture 降序  reverse = False 升序list04 = [1,5,6,8,-9,3]
list04.sort()
print(list04) #[-9, 1, 3, 5, 6, 8]

元组tuple

元组是序列类型的一种扩展

元组是一种序列类型，一旦创建就不能被修改  不能增删改

#使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔

#使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔
#创建
tuple01 = (1,2,3)
tuple02 = tuple() #空元组  ()
tuple03 = tuple((5,6,7))
print(tuple01)
print(tuple02)
print(tuple03)

查

 查询所有值  直接打印元组名字

 查询单个值  [index]

 查询多个值  [start:stop] 左开右闭 一负一正 

#字符串只能存放一个值  元组可以存放多个值，加个逗号可以进行区分

tuple02 = (1,2,3,4,5,6)print(tuple02)
print(tuple02[2])
print(tuple02[1:4])
print(tuple02[-5:-2])
print(tuple02[-5:4])

#创建
Str = ("张三")
print(type(Str)) #<class 'str'>
#字符串只能存放一个值  元组可以存放多个值，加个逗号可以进行区分
tuple01 = ("张三",)
print(type(tuple01)) #<class 'tuple'>
#复制完以后把数据变成元组
print(tuple01*3)  #('张三', '张三', '张三')

#len(tuple)  计算元组元素个数

#max(tuple)  返回元组中元素最大值

#min(tuple)  返回元组中元素最小值

 集合set

集合是多个元素的无序(没有下标)组合

集合类型与数学中的集合概念一致

集合元素之间无序，每个元素唯一，不存在相同元素

集合元素不可更改，不能是可变数据类型    

 无序唯一

• 集合用大括号 {} 表示，元素间用逗号分隔

• 建立集合类型用 {} 或 set()

• 建立空集合类型，必须使用set()

  #创建
  set01 = {1,2,3,4,5}
  set02 = set() #set()
  set03 = set({9,10,11})
  print(set01)
  print(set02) 
  print(set03)
  print(type({})) #<class 'dict'>
  print(type(set())) #<class 'set'>

  增

set.add(数据) 添加一个数据 不也能添加已有的数据，虽然不报错，但是不显示

set01.update(set02) 批量添加数据
  把set02添加到zet01中

#创建
set01 = {"花木兰","貂蝉","妲己","王昭君"}#set.add(数据) 添加一个数据  不也能添加已有的数据，虽然不报错，但是不显示set01.add("杨玉环")
print(set01) #{'花木兰', '王昭君', '貂蝉', '妲己', '杨玉环'}
set01.add("花木兰")
print(set01) #{'花木兰', '杨玉环', '王昭君', '妲己', '貂蝉'}#set01.update(set02) 批量添加数据
#把set02添加到zet01中set02 = {"嬴政","武则天"}
set01.update(set02)
print(set01) #{'花木兰', '嬴政', '杨玉环', '妲己', '王昭君', '武则天', '貂蝉'}

差

直接打印集合名字去查询

不能使用索引进行查询，因为我们集合是无序的

print(set01)
print(set02) 
print(set03)

集合常用函数和方法

#set.copy() 复制/拷贝一个一模一样的集合

#len(set) 返回集合的元素个数，集合的长度

 x in set 元素x在不在集合当中
 x not in set 元素不在集合中

#set(x) 把其他数据类型（x）转换成集合类型

#创建
set01 = {"喜羊羊","美羊羊","懒洋洋","沸羊羊","暖羊羊","慢羊羊","灰太狼"}#set.copy() 复制/拷贝一个一模一样的集合
set02 = set01.copy()
print(set02) #{'慢羊羊', '美羊羊', '灰太狼', '喜羊羊', '沸羊羊', '暖羊羊', '懒洋洋'}#len(set) 返回集合的元素个数，集合的长度
a = len(set01)
print(a) #7#x in set 元素x在不在集合当中#x not in set 元素不在集合中print("慢羊羊" in set01) #True
print("慢羊羊" not in set01) #False#set(x) 把其他数据类型（x）转换成集合类型 
Str = "hello"
print(Str) #hello
print(type(Str))b = set(Str)
print(type(b)) #<class 'set'>
print(b) #{'o', 'e', 'h', 'l'}

并差交补，包含关系

 交集

1.交的符号  &

   2.两个的公共部分

 补集

  1.补集的符号 ^

  2.并集-交集 = 补集

  3.除去公共部分，set01和set02的单独部分我都要

 并集

   1.他的符号是  |

   2.返回两个集合的所有值

 差集

   1.差的符号是  -

   2.set01 - set02  set01去掉公共部分的值

包含关系

 判断set01 和 set02是不是包含关系

 >  <   >=  <=

 口朝向那边，那边是大的

  set01 >= set02   set01包含set02

#并
print(set01 | set02)
#差
print(set01 - set02) 
print(set02 - set01) 
#交
print(set01 & set02)
#补
print(set01 ^ set02)
#包含关系
print(set01 >= set02)
print(set01 < set02)print(set02 < set01) 

字典dict

•   映射是一种键(索引)和值(数据)的对应

• 键值对：键是数据索引的扩展

• 字典是键值对的集合，键值对之间无序(没有索引）

• 采用大括号{}和dict()创建，键值对用冒号: 表示

• 字典类型是“映射”的体现

• <字典变量> = {<键1>:<值1>, … , <键n>:<值n>}

• 增

    dict01[新的key] = 新的值  添加数据

  删

   dict.pop(key)  根据key删除一对数据

   dict.clear()  清除所有数据

  改

    只能修改值，不可以修改key

    为什么：因为key是唯一的，不能重复的，避免出现重复的情况所以不能修改

    怎么修改： 

        先根据key拿到值  dict01["孙策"]

        再重新赋值

  查

   查询单个值

    1.dict[key]  利用key查询value

    2.dict.get(key,默认值)  利用key查询value 如果key没有，那么就输出默认值

   查询所有值(包括key和value)

    1.直接打印字典名

    2.dict.items() 迭代方法

#创建
dict01 = {"张三":18,"李四":20,"王五":80}
dict02 = dict()
dict03 = dict({"张三":90,"李四":20})
print(dict01)  #{'张三': 18, '李四': 20, '王': 80}
print(dict02) #{}
print(dict03)  #{'张三': 90, '李四': 20}增dict01["小乔"] = "天魔缭乱"
print(dict01) 删dict01.pop("元哥")
print(dict01) 改dict01["孙策"] = "乘风破浪"
print(dict01) 查
#创建
dict01 = {"鲁班":"空中支援","花木兰":"切换形态","孙策":"开船","元哥":"无敌时间移位"}# dict.keys()  查看所有的key(英雄)
print(dict01.keys()) #dict_keys(['鲁班', '花木兰', '孙策', '元哥'])# dict.values()  查询所有的value(大招)
print(dict01.values()) #dict_values(['空中支援', '切换形态', '开船', '无敌时间移位'])print(dict01["花木兰"]) #切换形态
print(dict01.get("花木兰"))  #切换形态
print(dict01.get("貂蝉","没有此英雄，请购买")) #没有此英雄，请购买print(dict01) 
print(dict01.items()) #dict_items([('鲁班', '空中支援'), ('花木兰', '切换形态'), ('孙策', '开船'), ('元哥', '无敌时间移位')])

常用的函数和方法

 k in dict    key在不在字典里面

 如果在输出True  如果不在输出False

 为什么 20 in dict0

   原因是他只能判断key在不在，不能判断value在不在

 dict01.update(dict02)  把02中的数据更新到01中

 更新是更新多个数据

 是复制吗？ no

 但是你可以理解成添加数据

del 字典名[key]  删除指定位置的数据

  和pop一样 

  dict.pop(key) 删除指定位置的数据

print("张三" in dict01) 
print(20 in dict01) 
#创建字典
dict01 = {"张三":20,"王五":30,"赵六":70,"李四":80}
dict02 = {"翠花":20,"光头强":10}
dict01.update(dict02)
print(dict01) 
print(dict02) #创建字典
dict01 = {"张三":20,"王五":30,"赵六":70,"李四":80}
dict02 = {"翠花":20,"光头强":10}del dict01["李四"]
print(dict01)

函数

编程语言的函数都可以分为两类：内置函数和自定义函数。

内置函数分为

数字相关的内置函数

# abs(x) 求绝对值

  divmod(x,y)  (x//y)商和(x%y)余数，同时输出商和余数

   x//y  整除  向下取整

   x%y  余数=被除数-除数*商  10%-3=-2

  pow(x,y) 幂 x的y次方 -------x**y

  pow(x,y,z) 先求x的y次方  得到的结果和z进行取余----x**y%z

#round(x,f) 四舍五入保留小数

#max(x1,x2,..........,xn) 返回最大值

 int(x) 将x转换成整数，舍弃小数部分

   可以把字符串转成整数,但是你的字符串必须是数字字符串 比如"123"

 float(x) 将x转换成小数，增加小数部分

   可以把字符串变成小数,但是字符串必须是数字字符串 比如"123" "22.9"

 complex(x) 将x变成复数，增加虚数部分

   x可以是整数 、小数、数字类型的字符串

• 进制的转换：bin()，oct()和hex()函数

"""

•进制的转换：

 bin() 转换成二进制(0b) 返回一个字符串

 oct() 转换成八进制(0o)  返回一个字符串

 hex() 转换成十六进制(0x) 返回一个字符串

"""

  chr(x) 把十进制转换成ASCLL编码字符

  ord(x) 把ASCLL编码字符转换成十进制

  all(序列)  all()接受一个序列 

    当序列中所有的元素都计算为真时，返回True，否则为False

  []  ()  {}  set()都是Flase

 any(x)  any()则在序列中的任意一个元素为真时返回True，否则为False

 range(start,stop) 迭代对象的生成  返回的是一个迭代对象，并不是一个列表类型

   1.迭代对象不能打印，所以使用list()转换成列表

   2.左开右闭

range(start,stop,step)

   step 步长

print(abs(-10)) x = 10
y = 3
print(divmod(10,3)) print(pow(x,y)) #1000
print(pow(x,y,3)) #1
print(pow(2,5,10))print(round(3.1415926,4)) print(max(4,6,9,1,0,10))print(int(3.92)) 
print(int("123"))print(float(12)) 
print(float("22"))print(complex(10)) #(10+0j)
print(complex(3.14)) #(3.14+0j)
print(complex("4.56"))a = bin(100)
print(a) #0b1100100
print(type(a)) #<class 'str'>print(ord("∞")) #8734
print(chr(64)) #@"""all(序列)  all()接受一个序列 当序列中所有的元素都计算为真时，返回True，否则为False[]  ()  {}  set()都是Flase
"""
a = ["hello",3.14,4+3j,{"张三":18,"李四":20}]
print(all(a)) #True
b = ["hello",3.14,4+3j,{"张三":18,"李四":20},[]]
print(all(b)) #False"""any(x)  any()则在序列中的任意一个元素为真时返回True，否则为False
"""
c = [{},(),set()]
print(any(c)) #False
"""range(start,stop) 迭代对象的生成  返回的是一个迭代对象，并不是一个列表类型1.迭代对象不能打印，所以使用list()转换成列表2.左开右闭
range(start,stop,step)step 步长
"""a = range(1,10) #a是一个迭代对象
print(a) #range(1, 10)
#list(a) 把a转换成list列表 
print(list(a)) #[1, 2, 3, 4, 5, 6, 7, 8, 9]b = range(1,10,2)
print(list(b)) #[1, 3, 5, 7, 9]

本文标签： python基础第三章