哪个网站有激光打标业务做,国外修图教程网站,碧桂园房地产最新消息,广州市官网网站建设哪家好Python3基础
想要获取pdf或markdown格式的笔记文件点击以下链接获取 Python入门学习笔记点击我获取
1#xff0c;Python3 基础语法
1-1 编码
默认情况下#xff0c;Python 3 源码文件以 UTF-8 编码#xff0c;所有字符串都是 unicode 字符串。 当然你也可以为源码文件指…Python3基础
想要获取pdf或markdown格式的笔记文件点击以下链接获取 Python入门学习笔记点击我获取
1Python3 基础语法
1-1 编码
默认情况下Python 3 源码文件以 UTF-8 编码所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码
# -*- coding: cp-1252 -*-上述定义允许在源文件中使用 Windows-1252 字符集中的字符编码对应适合语言为保加利亚语、白罗斯语、马其顿语、俄语、塞尔维亚语。 1-2 标识符
第一个字符必须是字母表中字母或下划线 _ 。标识符的其他的部分由字母、数字和下划线组成。标识符对大小写敏感。
在 Python 3 中可以用中文作为变量名非 ASCII 标识符也是允许的了。 1-3 python保留字
保留字即关键字我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块可以输出当前版本的所有关键字 import keywordkeyword.kwlist
[False, None, True, and, as, assert, break, class, continue, def, del, elif, else, except, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield]1-4 注释
Python中单行注释以 # 开头实例如下
#!/usr/bin/python3# 第一个注释
print (Hello, Python!) # 第二个注释执行以上代码输出结果为
Hello, Python!多行注释可以用多个 # 号还有 ‘’’ 和 “”
#!/usr/bin/python3# 第一个注释
# 第二个注释
第三注释
第四注释第五注释
第六注释print (Hello, Python!)执行以上代码输出结果为
Hello, Python!1-5 行与缩进
python最具特色的就是使用缩进来表示代码块不需要使用大括号 {} 。
缩进的空格数是可变的但是同一个代码块的语句必须包含相同的缩进空格数。实例如下
if True:print (True)
else:print (False)以下代码最后一行语句缩进数的空格数不一致会导致运行错误
if True:print (Answer)print (True)
else:print (Answer)print (False) # 缩进不一致会导致运行错误以上程序由于缩进不一致执行后会出现类似以下错误 File test.py, line 6print (False) # 缩进不一致会导致运行错误^
IndentationError: unindent does not match any outer indentation level1-6 多行语句
Python 通常是一行写完一条语句但如果语句很长我们可以使用反斜杠()来实现多行语句例如
total item_one \item_two \item_three在 [], {}, 或 () 中的多行语句不需要使用反斜杠()例如
total [item_one, item_two, item_three,item_four, item_five]1-7 数字(Number)类型
python中数字有四种类型整数、布尔型、浮点数和复数。
int (整数), 如 1, 只有一种整数类型 int表示为长整型没有 python2 中的 Long。bool (布尔), 如 True。float (浮点数), 如 1.23、3E-2complex (复数), 如 1 2j、 1.1 2.2j 1-8 字符串(String)
python中单引号和双引号使用完全相同。使用三引号(‘’或“”)可以指定一个多行字符串。转义符 ‘’反斜杠可以用来转义使用r可以让反斜杠不发生转义。。 如 rthis is a line with \n 则\n会显示并不是换行。按字面意义级联字符串如this is string会被自动转换为this is string。字符串可以用 运算符连接在一起用 * 运算符重复。Python 中的字符串有两种索引方式从左往右以 0 开始从右往左以 -1 开始。Python中的字符串不能改变。Python 没有单独的字符类型一个字符就是长度为 1 的字符串。字符串的截取的语法格式如下变量[头下标:尾下标:步长]
word 字符串
sentence 这是一个句子。
paragraph 这是一个段落
可以由多行组成#!/usr/bin/python3strRunoobprint(str) # 输出字符串
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符
print(str[0]) # 输出字符串第一个字符
print(str[2:5]) # 输出从第三个开始到第五个的字符
print(str[2:]) # 输出从第三个开始后的所有字符
print(str * 2) # 输出字符串两次
print(str 你好) # 连接字符串print(------------------------------)print(hello\nrunoob) # 使用反斜杠(\)n转义特殊字符
print(rhello\nrunoob) # 在字符串前面添加一个 r表示原始字符串不会发生转义这里的 r 指 raw即 raw string。
输出结果为
Runoob
Runoo
R
noo
noob
RunoobRunoob
Runoob你好
------------------------------
hello
runoob
hello\nrunoob1-9 空行
函数之间或类的方法之间用空行分隔表示一段新的代码的开始。类和函数入口之间也用一行空行分隔以突出函数入口的开始。
空行与代码缩进不同空行并不是Python语法的一部分。书写时不插入空行Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码便于日后代码的维护或重构。
**记住**空行也是程序代码的一部分。 1-10 等待用户输入
执行下面的程序在按回车键后就会等待用户输入
#!/usr/bin/python3input(\n\n按下 enter 键后退出。)以上代码中 \n\n在结果输出前会输出两个新的空行。一旦用户按下 enter 键时程序将退出。 1-11 同一行显示多条语句
Python可以在同一行中使用多条语句语句之间使用分号(;)分割以下是一个简单的实例
#!/usr/bin/python3import sys; x runoob; sys.stdout.write(x \n)使用脚本执行以上代码输出结果为
runoob使用交互式命令行执行输出结果为 import sys; x runoob; sys.stdout.write(x \n)
runoob
7此处的 7 表示字符数。 1-12 多个语句构成代码组
缩进相同的一组语句构成一个代码块我们称之代码组。
像if、while、def和class这样的复合语句首行以关键字开始以冒号( : )结束该行之后的一行或多行代码构成代码组。
我们将首行及后面的代码组称为一个子句(clause)。
如下实例
if expression : suite
elif expression : suite
else : suite1-13 Print 输出
print 默认输出是换行的如果要实现不换行需要在变量末尾加上 end“”
#!/usr/bin/python3xa
yb
# 换行输出
print( x )
print( y )print(---------)
# 不换行输出
print( x, end )
print( y, end )
print()以上实例执行结果为
a
b
---------
a b1-14 import 与 from…import
在 python 用 import 或者 from…import 来导入相应的模块。将整个模块(somemodule)导入格式为 import somemodule从某个模块中导入某个函数,格式为 from somemodule import somefunction从某个模块中导入多个函数,格式为 from somemodule import firstfunc, secondfunc, thirdfunc将某个模块中的全部函数导入格式为 from somemodule import *
# 导入 sys 模块
import sys
print(Python import mode)
print (命令行参数为:)
for i in sys.argv:print (i)
print (\n python 路径为,sys.path)
# 导入 sys 模块的 argv,path 成员
from sys import argv,path # 导入特定的成员print(python from import)
print(path:,path) # 因为已经导入path成员所以此处引用时不需要加sys.path1-15 命令行参数
很多程序可以执行一些操作来查看一些基本信息Python可以使用-h参数查看各参数帮助信息
$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d : debug output from parser (also PYTHONDEBUGx)
-E : ignore environment variables (such as PYTHONPATH)
-h : print this help message and exit[ etc. ]我们在使用脚本形式执行 Python 时可以接收命令行输入的参数具体使用可以参照 [Python 3 命令行参数](javascript:if(confirm(‘https://www.runoob.com/python3/dml.html \n\nļ Teleport Ultra , Ϊ , , Ŀֹͣ \n\nڷϴ?’))window.location‘https://www.runoob.com/python3/dml.html’)。
2Python3 基本数据类型
Python 中的变量不需要声明。每个变量在使用前都必须赋值变量赋值以后该变量才会被创建。在 Python 中变量就是变量它没有类型我们所说的类型是变量所指的内存中对象的类型。等号用来给变量赋值。等号运算符左边是一个变量名,等号运算符右边是存储在变量中的值。例如
#!/usr/bin/python3counter 100 # 整型变量
miles 1000.0 # 浮点型变量
name runoob # 字符串print (counter)
print (miles)
print (name)执行以上程序会输出如下结果
100
1000.0
runoob2-1 多个变量赋值
Python允许你同时为多个变量赋值。例如
a b c 1以上实例创建一个整型对象值为 1从后向前赋值三个变量被赋予相同的数值。
您也可以为多个对象指定多个变量。例如
a, b, c 1, 2, runoob以上实例两个整型对象 1 和 2 的分配给变量 a 和 b字符串对象 “runoob” 分配给变量 c。 2-2 标准数据类型
Python3 中有六个标准的数据类型
Number数字String字符串List列表Tuple元组Set集合Dictionary字典
Python3 的六个标准数据类型中
**不可变数据3 个**Number数字、String字符串、Tuple元组**可变数据3 个**List列表、Dictionary字典、Set集合。 2-3 Number数字
Python3 支持 int、float、bool、complex复数。
在Python 3里只有一种整数类型 int表示为长整型没有 python2 中的 Long。
像大多数语言一样数值类型的赋值和计算都是很直观的。
内置的 type() 函数可以用来查询变量所指的对象类型。 a, b, c, d 20, 5.5, True, 43jprint(type(a), type(b), type(c), type(d))
class int class float class bool class complex此外还可以用 isinstance 来判断
a 111isinstance(a, int)
Trueisinstance 和 type 的区别在于
type()不会认为子类是一种父类类型。isinstance()会认为子类是一种父类类型。 class A:
... pass
... class B(A):
... pass
... isinstance(A(), A)
Truetype(A()) A
Trueisinstance(B(), A)
Truetype(B()) A
False**注意**在 Python2 中是没有布尔型的它用数字 0 表示 False用 1 表示 True。到 Python3 中把 True 和 False 定义成关键字了但它们的值还是 1 和 0它们可以和数字相加。 当你指定一个值时Number 对象就会被创建
var1 1
var2 10您也可以使用del语句删除一些对象引用。
del语句的语法是
del var1[,var2[,var3[....,varN]]]您可以通过使用del语句删除单个或多个对象。例如
del var
del var_a, var_b2-4 数值运算
5 4 # 加法
94.3 - 2 # 减法
2.33 * 7 # 乘法
212 / 4 # 除法得到一个浮点数
0.52 // 4 # 除法得到一个整数
017 % 3 # 取余
22 ** 5 # 乘方
32注意
1、Python可以同时为多个变量赋值如a, b 1, 2。2、一个变量可以通过赋值指向不同类型的对象。3、数值的除法包含两个运算符/ 返回一个浮点数// 返回一个整数。4、在混合计算时Python会把整型转换成为浮点数。
2-5 数值类型实例 2-6 String字符串
Python中的字符串用单引号 ’ 或双引号 括起来同时使用反斜杠 ** 转义特殊字符。
字符串的截取的语法格式如下
变量[头下标:尾下标]加号 是字符串的连接符 星号 ***** 表示复制当前字符串紧跟的数字为复制的次数。实例如下
#!/usr/bin/python3str Runoobprint (str) # 输出字符串
print (str[0:-1]) # 输出第一个到倒数第二个的所有字符
print (str[0]) # 输出字符串第一个字符
print (str[2:5]) # 输出从第三个开始到第五个的字符
print (str[2:]) # 输出从第三个开始的后的所有字符
print (str * 2) # 输出字符串两次
print (str TEST) # 连接字符串执行以上程序会输出如下结果
Runoob
Runoo
R
noo
noob
RunoobRunoob
RunoobTESTPython 使用反斜杠()转义特殊字符如果你不想让反斜杠发生转义可以在字符串前面添加一个 r表示原始字符串 print(Ru\noob)
Ru
oobprint(rRu\noob)
Ru\noob另外反斜杠()可以作为续行符表示下一行是上一行的延续。也可以使用 “”“…”“” 或者 ‘’‘…’‘’ 跨越多行。
注意Python 没有单独的字符类型一个字符就是长度为1的字符串。
word Pythonprint(word[0], word[5])
P nprint(word[-1], word[-6])
n P与 C 字符串不同的是Python 字符串不能被改变。向一个索引位置赋值比如word[0] m’会导致错误。
注意
1、反斜杠可以用来转义使用r可以让反斜杠不发生转义。2、字符串可以用运算符连接在一起用*运算符重复。3、Python中的字符串有两种索引方式从左往右以0开始从右往左以-1开始。4、Python中的字符串不能改变。 2-7 List列表
List列表 是 Python 中使用最频繁的数据类型。列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同它支持数字字符串甚至可以包含列表所谓嵌套。列表是写在方括号 [] 之间、用逗号分隔开的元素列表。和字符串一样列表同样可以被索引和截取列表被截取后返回一个包含所需元素的新列表。列表截取的语法格式如下
加号 是列表连接运算符星号 ***** 是重复操作。如下实例
#!/usr/bin/python3list [ abcd, 786 , 2.23, runoob, 70.2 ]
tinylist [123, runoob]print (list) # 输出完整列表
print (list[0]) # 输出列表第一个元素
print (list[1:3]) # 从第二个开始输出到第三个元素
print (list[2:]) # 输出从第三个元素开始的所有元素
print (tinylist * 2) # 输出两次列表
print (list tinylist) # 连接列表以上实例输出结果
[abcd, 786, 2.23, runoob, 70.2]
abcd
[786, 2.23]
[2.23, runoob, 70.2]
[123, runoob, 123, runoob]
[abcd, 786, 2.23, runoob, 70.2, 123, runoob]与Python字符串不一样的是列表中的元素是可以改变的
a [1, 2, 3, 4, 5, 6]a[0] 9a[2:5] [13, 14, 15]a
[9, 2, 13, 14, 15, 6]a[2:5] [] # 将对应的元素值设置为 [] a
[9, 2, 6]List 内置了有很多方法例如 append()、pop() 等等这在后面会讲到。
注意
1、List写在方括号之间元素用逗号隔开。2、和字符串一样list可以被索引和切片。3、List可以使用操作符进行拼接。4、List中的元素是可以改变的。
Python 列表截取可以接收第三个参数参数作用是截取的步长以下实例在索引 1 到索引 4 的位置并设置为步长为 2间隔一个位置来截取字符串
如果第三个参数为负数表示逆向读取以下实例用于翻转字符串
def reverseWords(input):# 通过空格将字符串分隔符把各个单词分隔为列表inputWords input.split( )# 翻转字符串# 假设列表 list [1,2,3,4], # list[0]1, list[1]2 而 -1 表示最后一个元素 list[-1]4 ( 与 list[3]4 一样)# inputWords[-1::-1] 有三个参数# 第一个参数 -1 表示最后一个元素# 第二个参数为空表示移动到列表末尾# 第三个参数为步长-1 表示逆向inputWordsinputWords[-1::-1]# 重新组合字符串output .join(inputWords)return outputif __name__ __main__:input I like runoobrw reverseWords(input)print(rw)输出结果为
runoob like I2-8 Tuple元组
元组tuple与列表类似不同之处在于元组的元素不能修改。元组写在小括号 () 里元素之间用逗号隔开。
元组中的元素类型也可以不相同
#!/usr/bin/python3tuple ( abcd, 786 , 2.23, runoob, 70.2 )
tinytuple (123, runoob)print (tuple) # 输出完整元组
print (tuple[0]) # 输出元组的第一个元素
print (tuple[1:3]) # 输出从第二个元素开始到第三个元素
print (tuple[2:]) # 输出从第三个元素开始的所有元素
print (tinytuple * 2) # 输出两次元组
print (tuple tinytuple) # 连接元组以上实例输出结果
(abcd, 786, 2.23, runoob, 70.2)
abcd
(786, 2.23)
(2.23, runoob, 70.2)
(123, runoob, 123, runoob)
(abcd, 786, 2.23, runoob, 70.2, 123, runoob)元组与字符串类似可以被索引且下标索引从0开始-1 为从末尾开始的位置。也可以进行截取看上面这里不再赘述。
其实可以把字符串看作一种特殊的元组。
tup (1, 2, 3, 4, 5, 6)print(tup[0])
1print(tup[1:5])
(2, 3, 4, 5)tup[0] 11 # 修改元组元素的操作是非法的
Traceback (most recent call last):File stdin, line 1, in module
TypeError: tuple object does not support item assignment虽然tuple的元素不可改变但它可以包含可变的对象比如list列表。
构造包含 0 个或 1 个元素的元组比较特殊所以有一些额外的语法规则
tup1 () # 空元组
tup2 (20,) # 一个元素需要在元素后添加逗号string、list 和 tuple 都属于 sequence序列。
注意
1、与字符串一样元组的元素不能修改。2、元组也可以被索引和切片方法一样。3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。4、元组也可以使用操作符进行拼接。
2-9 Set集合
集合set是由一个或数个形态各异的大小整体组成的构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合注意创建一个空集合必须用 set() 而不是 { }因为 { } 是用来创建一个空字典。
创建格式
parame {value01,value02,...}
或者
set(value)#!/usr/bin/python3student {Tom, Jim, Mary, Tom, Jack, Rose}print(student) # 输出集合重复的元素被自动去掉# 成员测试
if Rose in student :print(Rose 在集合中)
else :print(Rose 不在集合中)# set可以进行集合运算
a set(abracadabra)
b set(alacazam)print(a)print(a - b) # a 和 b 的差集print(a | b) # a 和 b 的并集print(a b) # a 和 b 的交集print(a ^ b) # a 和 b 中不同时存在的元素以上实例输出结果
{Mary, Jim, Rose, Jack, Tom}
Rose 在集合中
{b, a, c, r, d}
{b, d, r}
{l, r, a, c, z, m, b, d}
{a, c}
{l, r, z, m, b, d}2-10 Dictionary字典
字典dictionary是Python中另一个非常有用的内置数据类型。列表是有序的对象集合字典是无序的对象集合。两者之间的区别在于字典当中的元素是通过键来存取的而不是通过偏移存取。字典是一种映射类型字典用 { } 标识它是一个无序的 键(key) : 值(value) 的集合。键(key)必须使用不可变类型。在同一个字典中键(key)必须是唯一的。
#!/usr/bin/python3dict {}
dict[one] 1 - 菜鸟教程
dict[2] 2 - 菜鸟工具tinydict {name: runoob,code:1, site: www.runoob.com}print (dict[one]) # 输出键为 one 的值
print (dict[2]) # 输出键为 2 的值
print (tinydict) # 输出完整的字典
print (tinydict.keys()) # 输出所有键
print (tinydict.values()) # 输出所有值以上实例输出结果
1 - 菜鸟教程
2 - 菜鸟工具
{name: runoob, code: 1, site: www.runoob.com}
dict_keys([name, code, site])
dict_values([runoob, 1, www.runoob.com])构造函数 dict() 可以直接从键值对序列中构建字典如下
dict([(Runoob, 1), (Google, 2), (Taobao, 3)])
{Taobao: 3, Runoob: 1, Google: 2} {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36} dict(Runoob1, Google2, Taobao3)
{Runoob: 1, Google: 2, Taobao: 3}另外字典类型也有一些内置的函数例如clear()、keys()、values()等。
注意
1、字典是一种映射类型它的元素是键值对。2、字典的关键字必须为不可变类型且不能重复。3、创建空字典使用 { }。 2-11 Python数据类型转换
有时候我们需要对数据内置的类型进行转换数据类型的转换你只需要将数据类型作为函数名即可。
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象表示转换的值。 3Python3 解释器
Linux/Unix的系统上一般默认的 python 版本为 2.x我们可以将 python3.x 安装在 /usr/local/python3 目录中。
安装完成后我们可以将路径 /usr/local/python3/bin 添加到您的 Linux/Unix 操作系统的环境变量中这样您就可以通过 shell 终端输入下面的命令来启动 Python3 。
$ PATH$PATH:/usr/local/python3/bin/python3 # 设置环境变量
$ python3 --version
Python 3.4.0在Window系统下你可以通过以下命令来设置Python的环境变量假设你的Python安装在 C:\Python34 下:
set path%path%;C:\python343-1 交互式编程
我们可以在命令提示符中输入Python命令来启动Python解释器
$ python3执行以上命令后出现如下窗口信息
$ python3
Python 3.4.0 (default, Apr 11 2014, 13:05:11)
[GCC 4.8.2] on linux
Type help, copyright, credits or license for more information.在 python 提示符中输入以下语句然后按回车键查看运行效果
print (Hello, Python!);以上命令执行结果如下
Hello, Python!当键入一个多行结构时续行是必须的。我们可以看下如下 if 语句 flag Trueif flag :
... print(flag 条件为 True!)
...
flag 条件为 True!3-2 脚本式编程
将如下代码拷贝至 hello.py文件中
print (Hello, Python!);通过以下命令执行该脚本
python3 hello.py输出结果为
Hello, Python!在Linux/Unix系统中你可以在脚本顶部添加以下命令让Python脚本可以像SHELL脚本一样可直接执行
#! /usr/bin/env python3然后修改脚本权限使其有执行权限命令如下
$ chmod x hello.py执行以下命令
./hello.py输出结果为
Hello, Python!4Python3 注释
确保对模块, 函数, 方法和行内注释使用正确的风格
Python中的注释有单行注释和多行注释
Python中单行注释以 # 开头例如
# 这是一个注释
print(Hello, World!)多行注释用三个单引号 ‘’’ 或者三个双引号 “” 将注释括起来例如:
4-1 单引号‘’
#!/usr/bin/python3 这是多行注释用三个单引号
这是多行注释用三个单引号
这是多行注释用三个单引号print(Hello, World!)4-2 双引号“”
#!/usr/bin/python3 这是多行注释用三个双引号
这是多行注释用三个双引号
这是多行注释用三个双引号print(Hello, World!)5Python运算符
5-1 Python算术运算符
以下假设变量a为10变量b为21 以下实例演示了Python所有算术运算符的操作
#!/usr/bin/python3a 21
b 10
c 0c a b
print (1 - c 的值为, c)c a - b
print (2 - c 的值为, c)c a * b
print (3 - c 的值为, c)c a / b
print (4 - c 的值为, c)c a % b
print (5 - c 的值为, c)# 修改变量 a 、b 、c
a 2
b 3
c a**b
print (6 - c 的值为, c)a 10
b 5
c a//b
print (7 - c 的值为, c)以上实例输出结果
1 - c 的值为 31
2 - c 的值为 11
3 - c 的值为 210
4 - c 的值为 2.1
5 - c 的值为 1
6 - c 的值为 8
7 - c 的值为 25-2 Python比较运算符
以下假设变量a为10变量b为20 以下实例演示了Python所有比较运算符的操作
#!/usr/bin/python3a 21
b 10
c 0if ( a b ):print (1 - a 等于 b)
else:print (1 - a 不等于 b)if ( a ! b ):print (2 - a 不等于 b)
else:print (2 - a 等于 b)if ( a b ):print (3 - a 小于 b)
else:print (3 - a 大于等于 b)if ( a b ):print (4 - a 大于 b)
else:print (4 - a 小于等于 b)# 修改变量 a 和 b 的值
a 5;
b 20;
if ( a b ):print (5 - a 小于等于 b)
else:print (5 - a 大于 b)if ( b a ):print (6 - b 大于等于 a)
else:print (6 - b 小于 a)以上实例输出结果
1 - a 不等于 b
2 - a 不等于 b
3 - a 大于等于 b
4 - a 大于 b
5 - a 小于等于 b
6 - b 大于等于 a5-3 Python赋值运算符
以下假设变量a为10变量b为20 #!/usr/bin/python3a 21
b 10
c 0c a b
print (1 - c 的值为, c)c a
print (2 - c 的值为, c)c * a
print (3 - c 的值为, c)c / a
print (4 - c 的值为, c)c 2
c % a
print (5 - c 的值为, c)c ** a
print (6 - c 的值为, c)c // a
print (7 - c 的值为, c)以上实例输出结果
1 - c 的值为 31
2 - c 的值为 52
3 - c 的值为 1092
4 - c 的值为 52.0
5 - c 的值为 2
6 - c 的值为 2097152
7 - c 的值为 998645-4 Python位运算符
按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下
下表中变量 a 为 60b 为 13二进制格式如下
a 0011 1100b 0000 1101-----------------ab 0000 1100a|b 0011 1101a^b 0011 0001~a 1100 0011#!/usr/bin/python3a 60 # 60 0011 1100
b 13 # 13 0000 1101
c 0c a b; # 12 0000 1100
print (1 - c 的值为, c)c a | b; # 61 0011 1101
print (2 - c 的值为, c)c a ^ b; # 49 0011 0001
print (3 - c 的值为, c)c ~a; # -61 1100 0011
print (4 - c 的值为, c)c a 2; # 240 1111 0000
print (5 - c 的值为, c)c a 2; # 15 0000 1111
print (6 - c 的值为, c)以上实例输出结果
1 - c 的值为 12
2 - c 的值为 61
3 - c 的值为 49
4 - c 的值为 -61
5 - c 的值为 240
6 - c 的值为 155-5 Python逻辑运算符
Python语言支持逻辑运算符以下假设变量 a 为 10, b为 20: #!/usr/bin/python3a 10
b 20if ( a and b ):print (1 - 变量 a 和 b 都为 true)
else:print (1 - 变量 a 和 b 有一个不为 true)if ( a or b ):print (2 - 变量 a 和 b 都为 true或其中一个变量为 true)
else:print (2 - 变量 a 和 b 都不为 true)# 修改变量 a 的值
a 0
if ( a and b ):print (3 - 变量 a 和 b 都为 true)
else:print (3 - 变量 a 和 b 有一个不为 true)if ( a or b ):print (4 - 变量 a 和 b 都为 true或其中一个变量为 true)
else:print (4 - 变量 a 和 b 都不为 true)if not( a and b ):print (5 - 变量 a 和 b 都为 false或其中一个变量为 false)
else:print (5 - 变量 a 和 b 都为 true)以上实例输出结果
1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true或其中一个变量为 true
5 - 变量 a 和 b 都为 false或其中一个变量为 false5-6 Python成员运算符
除了以上的一些运算符之外Python还支持成员运算符测试实例中包含了一系列的成员包括字符串列表或元组。 #!/usr/bin/python3a 10
b 20
list [1, 2, 3, 4, 5 ];if ( a in list ):print (1 - 变量 a 在给定的列表中 list 中)
else:print (1 - 变量 a 不在给定的列表中 list 中)if ( b not in list ):print (2 - 变量 b 不在给定的列表中 list 中)
else:print (2 - 变量 b 在给定的列表中 list 中)# 修改变量 a 的值
a 2
if ( a in list ):print (3 - 变量 a 在给定的列表中 list 中)
else:print (3 - 变量 a 不在给定的列表中 list 中)以上实例输出结果
1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中5-7 Python身份运算符
身份运算符用于比较两个对象的存储单元 注 [id()](javascript:if(confirm(‘https://www.runoob.com/python/extend.html \n\nļ Teleport Ultra , Ϊ , , Ŀֹͣ \n\nڷϴ?’))window.location‘https://www.runoob.com/python/extend.html’) 函数用于获取对象内存地址。
以下实例演示了Python所有身份运算符的操作
#!/usr/bin/python3a 20
b 20if ( a is b ):print (1 - a 和 b 有相同的标识)
else:print (1 - a 和 b 没有相同的标识)if ( id(a) id(b) ):print (2 - a 和 b 有相同的标识)
else:print (2 - a 和 b 没有相同的标识)# 修改变量 b 的值
b 30
if ( a is b ):print (3 - a 和 b 有相同的标识)
else:print (3 - a 和 b 没有相同的标识)if ( a is not b ):print (4 - a 和 b 没有相同的标识)
else:print (4 - a 和 b 有相同的标识)以上实例输出结果
1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识is 与 区别
is 用于判断两个变量引用对象是否为同一个 用于判断引用变量的值是否相等。
a [1, 2, 3]b ab is a
Trueb a
Trueb a[:]b is a
Falseb a
True5-8 Python运算符优先级 以下实例演示了Python所有运算符优先级的操作
#!/usr/bin/python3a 20
b 10
c 15
d 5
e 0e (a b) * c / d #( 30 * 15 ) / 5
print ((a b) * c / d 运算结果为, e)e ((a b) * c) / d # (30 * 15 ) / 5
print (((a b) * c) / d 运算结果为, e)e (a b) * (c / d); # (30) * (15/5)
print ((a b) * (c / d) 运算结果为, e)e a (b * c) / d; # 20 (150/5)
print (a (b * c) / d 运算结果为, e)以上实例输出结果
(a b) * c / d 运算结果为 90.0
((a b) * c) / d 运算结果为 90.0
(a b) * (c / d) 运算结果为 90.0
a (b * c) / d 运算结果为 50.0**注意**Pyhton3 已不支持 运算符可以使用 ! 代替如果你一定要使用这种比较运算符可以使用以下的方式 from __future__ import barry_as_FLUFL1 2
True6 Python3 数字(Number)
Python 数字数据类型用于存储数值。
数据类型是不允许改变的,这就意味着如果改变数字数据类型的值将重新分配内存空间。
以下实例在变量赋值时 Number 对象将被创建
var1 1
var2 10您也可以使用del语句删除一些数字对象的引用。
del语句的语法是
del var1[,var2[,var3[....,varN]]]您可以通过使用del语句删除单个或多个对象的引用例如
del var
del var_a, var_bPython 支持三种不同的数值类型
整型(Int) - 通常被称为是整型或整数是正或负整数不带小数点。Python3 整型是没有限制大小的可以当作 Long 类型使用所以 Python3 没有 Python2 的 Long 类型。浮点型(float) - 浮点型由整数部分与小数部分组成浮点型也可以使用科学计数法表示2.5e2 2.5 x 102 250复数( (complex)) - 复数由实数部分和虚数部分构成可以用a bj,或者complex(a,b)表示 复数的实部a和虚部b都是浮点型。
我们可以使用十六进制和八进制来代表整数 number 0xA0F # 十六进制number
2575 number0o37 # 八进制number
316-1 Python 数字类型转换
有时候我们需要对数据内置的类型进行转换数据类型的转换你只需要将数据类型作为函数名即可。
int(x) 将x转换为一个整数。float(x) 将x转换到一个浮点数。complex(x) 将x转换到一个复数实数部分为 x虚数部分为 0。complex(x, y) 将 x 和 y 转换到一个复数实数部分为 x虚数部分为 y。x 和 y 是数字表达式。
以下实例将浮点数变量 a 转换为整数 a 1.0int(a)
16-2 Python 数字运算
Python 解释器可以作为一个简单的计算器您可以在解释器里输入一个表达式它将输出表达式的值。
表达式的语法很直白 , -, ***** 和 /, 和其它语言如Pascal或C里一样。例如 2 2
450 - 5*6
20(50 - 5*6) / 4
5.08 / 5 # 总是返回一个浮点数
1.6**注意**在不同的机器上浮点运算的结果可能会不一样。
在整数除法中除法 / 总是返回一个浮点数如果只想得到整数的结果丢弃可能的分数部分可以使用运算符 // 17 / 3 # 整数除法返回浮点型
5.66666666666666717 // 3 # 整数除法返回向下取整后的结果
517 % 3 # 操作符返回除法的余数
25 * 3 2
17注意****// 得到的并不一定是整数类型的数它与分母分子的数据类型有关系。 7//2
37.0//2
3.07//2.0
3.0等号 用于给变量赋值。赋值之后除了下一个提示符解释器不会显示任何结果。 width 20height 5*9width * height
900Python 可以使用 ** 操作来进行幂运算 5 ** 2 # 5 的平方
252 ** 7 # 2的7次方
128变量在使用前必须先定义即赋予变量一个值否则会出现错误 n # 尝试访问一个未定义的变量
Traceback (most recent call last):File stdin, line 1, in module
NameError: name n is not defined不同类型的数混合运算时会将整数转换为浮点数 3 * 3.75 / 1.5
7.57.0 / 2
3.5在交互模式中最后被输出的表达式结果被赋值给变量 _ 。例如 tax 12.5 / 100price 100.50price * tax
12.5625price _
113.0625round(_, 2)
113.06此处 _ 变量应被用户视为只读变量。
6-3 数学函数 6-4 随机数函数
随机数可以用于数学游戏安全等领域中还经常被嵌入到算法中用以提高算法效率并提高程序的安全性。
Python包含以下常用随机数函数 6-5 三角函数
Python包括以下三角函数 6-6 数学常量 7Python3 字符串
字符串是 Python 中最常用的数据类型。我们可以使用引号( ’ 或 )来创建字符串。
创建字符串很简单只要为变量分配一个值即可。例如
var1 Hello World!
var2 Runoob7-1 Python 访问字符串中的值
Python 不支持单字符类型单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串可以使用方括号来截取字符串如下实例
#!/usr/bin/python3var1 Hello World!
var2 Runoobprint (var1[0]: , var1[0])
print (var2[1:5]: , var2[1:5])以上实例执行结果
var1[0]: H
var2[1:5]: unoo7-2 Python 字符串更新
你可以截取字符串的一部分并与其他字段拼接如下实例
#!/usr/bin/python3var1 Hello World!print (已更新字符串 : , var1[:6] Runoob!)以上实例执行结果
已更新字符串 : Hello Runoob!7-3 Python转义字符
在需要在字符中使用特殊字符时python用反斜杠()转义字符。如下表 7-4 Python字符串运算符
下表实例变量a值为字符串 “Hello”b变量值为 “Python” #!/usr/bin/python3a Hello
b Pythonprint(a b 输出结果, a b)
print(a * 2 输出结果, a * 2)
print(a[1] 输出结果, a[1])
print(a[1:4] 输出结果, a[1:4])if( H in a) :print(H 在变量 a 中)
else :print(H 不在变量 a 中)if( M not in a) :print(M 不在变量 a 中)
else :print(M 在变量 a 中)print (r\n)
print (R\n)以上实例输出结果为
a b 输出结果 HelloPython
a * 2 输出结果 HelloHello
a[1] 输出结果 e
a[1:4] 输出结果 ell
H 在变量 a 中
M 不在变量 a 中
\n
\n7-5 Python字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中字符串格式化使用与 C 中 sprintf 函数一样的语法。
#!/usr/bin/python3print (我叫 %s 今年 %d 岁! % (小明, 10))以上实例输出结果
我叫 小明 今年 10 岁!python字符串格式化符号: 格式化操作符辅助指令: 7-6 Python三引号
python三引号允许一个字符串跨多行字符串中可以包含换行符、制表符以及其他特殊字符。实例如下
#!/usr/bin/python3para_str 这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。print (para_str)以上实例执行结果为
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( )。
也可以使用换行符 [ ]。三引号让程序员从引号和特殊字符串的泥潭里面解脱出来自始至终保持一小块字符串的格式是所谓的WYSIWYG所见即所得格式的。
一个典型的用例是当你需要一块HTML或者SQL时这时用字符串组合特殊字符串转义将会非常的繁琐。
errHTML
HTMLHEADTITLE
Friends CGI Demo/TITLE/HEAD
BODYH3ERROR/H3
B%s/BP
FORMINPUT TYPEbutton VALUEBack
ONCLICKwindow.history.back()/FORM
/BODY/HTMLcursor.execute(
CREATE TABLE users (
login VARCHAR(8),
uid INTEGER,
prid INTEGER)
)7-7 f-string
f-string 是 python3.6 之后版本添加的称之为字面量格式化字符串是新的格式化字符串的语法。
之前我们习惯用百分号 (%): name RunoobHello %s % name
Hello Runoobf-string 格式话字符串以 f 开头后面跟着字符串字符串中的表达式用大括号 {} 包起来它会将变量或表达式计算后的值替换进去实例如下 name RunoobfHello {name} # 替换变量 f{12} # 使用表达式
3 w {name: Runoob, url: www.runoob.com}f{w[name]}: {w[url]}
Runoob: www.runoob.com用了这种方式明显更简单了不用再去判断使用 %s还是 %d。
在 Python 3.8 的版本中可以使用 符号来拼接运算表达式与结果 x 1print(f{x1}) # Python 3.6
2 x 1print(f{x1}) # Python 3.8
x127-8 Unicode 字符串
在Python2中普通字符串是以8位ASCII码进行存储的而Unicode字符串则存储为16位unicode字符串这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。
在Python3中所有的字符串都是Unicode字符串。 7-9 Python 的字符串内建函数
Python 的字符串常用内建函数如下 8Python3 列表
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置或索引第一个索引是0第二个索引是1依此类推。Python有6个序列的内置类型但最常见的是列表和元组。序列都可以进行的操作包括索引切片加乘检查成员。此外Python已经内置确定序列的长度以及确定最大和最小的元素的方法。列表是最常用的Python数据类型它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型创建一个列表只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示
list1 [Google, Runoob, 1997, 2000];
list2 [1, 2, 3, 4, 5 ];
list3 [a, b, c, d];与字符串的索引一样列表索引从0开始。列表可以进行截取、组合等。
8-1 访问列表中的值
使用下标索引来访问列表中的值同样你也可以使用方括号的形式截取字符如下所示
#!/usr/bin/python3list1 [Google, Runoob, 1997, 2000];
list2 [1, 2, 3, 4, 5, 6, 7 ];print (list1[0]: , list1[0])
print (list2[1:5]: , list2[1:5])以上实例输出结果
list1[0]: Google
list2[1:5]: [2, 3, 4, 5]8-2 更新列表
你可以对列表的数据项进行修改或更新你也可以使用append()方法来添加列表项如下所示
#!/usr/bin/python3list [Google, Runoob, 1997, 2000]print (第三个元素为 : , list[2])
list[2] 2001
print (更新后的第三个元素为 : , list[2])**注意**我们会在接下来的章节讨论append()方法的使用
以上实例输出结果
第三个元素为 : 1997
更新后的第三个元素为 : 20018-3 删除列表元素
可以使用 del 语句来删除列表的的元素如下实例
#!/usr/bin/python3list [Google, Runoob, 1997, 2000]print (原始列表 : , list)
del list[2]
print (删除第三个元素 : , list)以上实例输出结果
原始列表 : [Google, Runoob, 1997, 2000]
删除第三个元素 : [Google, Runoob, 2000]**注意**我们会在接下来的章节讨论 remove() 方法的使用
8-4 Python列表脚本操作符
列表对 和 * 的操作符与字符串相似。 号用于组合列表* 号用于重复列表。
如下所示 8-5 Python列表截取与拼接
Python的列表截取与字符串操作类型如下所示
L[Google, Runoob, Taobao]L[Google, Runoob, Taobao]L[2]
TaobaoL[-2]
RunoobL[1:]
[Runoob, Taobao]列表还支持拼接操作
squares [1, 4, 9, 16, 25]squares [36, 49, 64, 81, 100]squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]8-6 嵌套列表
使用嵌套列表即在列表里创建其它列表例如
a [a, b, c]n [1, 2, 3]x [a, n]x
[[a, b, c], [1, 2, 3]]x[0]
[a, b, c]x[0][1]
b8-7 Python列表函数方法
Python包含以下函数: Python包含以下方法: 9Python3 元组
Python 的元组与列表类似不同之处在于元组的元素不能修改。元组使用小括号列表使用方括号。元组创建很简单只需要在括号中添加元素并使用逗号隔开即可。
tup1 (Google, Runoob, 1997, 2000);tup2 (1, 2, 3, 4, 5 );tup3 a, b, c, d; # 不需要括号也可以type(tup3)
class tuple创建空元组
tup1 ();元组中只包含一个元素时需要在元素后面添加逗号否则括号会被当作运算符使用
tup1 (50)type(tup1) # 不加逗号类型为整型
class int tup1 (50,)type(tup1) # 加上逗号类型为元组
class tuple元组与字符串类似下标索引从0开始可以进行截取组合等。
9-1 访问元组
元组可以使用下标索引来访问元组中的值如下实例:
#!/usr/bin/python3tup1 (Google, Runoob, 1997, 2000)
tup2 (1, 2, 3, 4, 5, 6, 7 )print (tup1[0]: , tup1[0])
print (tup2[1:5]: , tup2[1:5])以上实例输出结果
tup1[0]: Google
tup2[1:5]: (2, 3, 4, 5)9-2 修改元组
元组中的元素值是不允许修改的但我们可以对元组进行连接组合如下实例:
#!/usr/bin/python3tup1 (12, 34.56);
tup2 (abc, xyz)# 以下修改元组元素操作是非法的。
# tup1[0] 100# 创建一个新的元组
tup3 tup1 tup2;
print (tup3)以上实例输出结果
(12, 34.56, abc, xyz)9-3 删除元组
元组中的元素值是不允许删除的但我们可以使用del语句来删除整个元组如下实例:
#!/usr/bin/python3tup (Google, Runoob, 1997, 2000)print (tup)
del tup;
print (删除后的元组 tup : )
print (tup)以上实例元组被删除后输出变量会有异常信息输出如下所示
删除后的元组 tup :
Traceback (most recent call last):File test.py, line 8, in moduleprint (tup)
NameError: name tup is not defined9-4 元组运算符
与字符串一样元组之间可以使用 号和 * 号进行运算。这就意味着他们可以组合和复制运算后会生成一个新的元组。 9-5 元组索引截取
因为元组也是一个序列所以我们可以访问元组中的指定位置的元素也可以截取索引中的一段元素如下所示
元组
L (Google, Taobao, Runoob)运行实例如下 L (Google, Taobao, Runoob)L[2]
RunoobL[-2]
TaobaoL[1:]
(Taobao, Runoob)9-6 元组内置函数
Python元组包含了以下内置函数 9-7 关于元组是不可变的
所谓元组的不可变指的是元组所指向的内存中的内同不可变。 tup (r, u, n, o, o, b)tup[0] g # 不支持修改元素
Traceback (most recent call last):File stdin, line 1, in module
TypeError: tuple object does not support item assignmentid(tup) # 查看内存地址
4440687904tup (1,2,3)id(tup)
4441088800 # 内存地址不一样了从以上实例可以看出重新赋值的元组 tup绑定到新的对象了不是修改了原来的对象。
10Python3 字典
字典是另一种可变容器模型且可存储任意类型对象。
字典的每个键值(keyvalue)对用冒号(:)分割每个对之间用逗号(,)分割整个字典包括在花括号(**{})**中 ,格式如下所示
d {key1 : value1, key2 : value2 }键必须是唯一的但值则不必。
值可以取任何数据类型但键必须是不可变的如字符串数字或元组。
一个简单的字典实例
dict {Alice: 2341, Beth: 9102, Cecil: 3258}也可如此创建字典
dict1 { abc: 456 }
dict2 { abc: 123, 98.6: 37 }10-1 访问字典里的值
把相应的键放入到方括号中如下实例:
#!/usr/bin/python3dict {Name: Runoob, Age: 7, Class: First}print (dict[Name]: , dict[Name])
print (dict[Age]: , dict[Age])以上实例输出结果
dict[Name]: Runoob
dict[Age]: 7如果用字典里没有的键访问数据会输出错误如下
#!/usr/bin/python3dict {Name: Runoob, Age: 7, Class: First}print (dict[Alice]: , dict[Alice])以上实例输出结果
Traceback (most recent call last):File test.py, line 5, in moduleprint (dict[Alice]: , dict[Alice])
KeyError: Alice10-2 修改字典
向字典添加新内容的方法是增加新的键/值对修改或删除已有键/值对如下实例:
#!/usr/bin/python3dict {Name: Runoob, Age: 7, Class: First}dict[Age] 8 # 更新 Age
dict[School] 菜鸟教程 # 添加信息print (dict[Age]: , dict[Age])
print (dict[School]: , dict[School])以上实例输出结果
dict[Age]: 8
dict[School]: 菜鸟教程10-3 删除字典元素
能删单一的元素也能清空字典清空只需一项操作。
显示删除一个字典用del命令如下实例
#!/usr/bin/python3dict {Name: Runoob, Age: 7, Class: First}del dict[Name] # 删除键 Name
dict.clear() # 清空字典
del dict # 删除字典print (dict[Age]: , dict[Age])
print (dict[School]: , dict[School])但这会引发一个异常因为用执行 del 操作后字典不再存在
Traceback (most recent call last):File test.py, line 9, in moduleprint (dict[Age]: , dict[Age])
TypeError: type object is not subscriptable**注**del() 方法后面也会讨论。
10-4 字典键的特性
字典值可以是任何的 python 对象既可以是标准的对象也可以是用户定义的但键不行。
两个重要的点需要记住
1不允许同一个键出现两次。创建时如果同一个键被赋值两次后一个值会被记住如下实例
#!/usr/bin/python3dict {Name: Runoob, Age: 7, Name: 小菜鸟}print (dict[Name]: , dict[Name])以上实例输出结果
dict[Name]: 小菜鸟2键必须不可变所以可以用数字字符串或元组充当而用列表就不行如下实例
#!/usr/bin/python3dict {[Name]: Runoob, Age: 7}print (dict[Name]: , dict[Name])以上实例输出结果
Traceback (most recent call last):File test.py, line 3, in moduledict {[Name]: Runoob, Age: 7}
TypeError: unhashable type: list10-5 字典内置函数方法
Python字典包含了以下内置函数 Python字典包含了以下内置方法 11Python3 集合
集合set是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合注意创建一个空集合必须用 set() 而不是 { }因为 { } 是用来创建一个空字典。
创建格式
parame {value01,value02,...}
或者
set(value)basket {apple, orange, apple, pear, orange, banana}print(basket) # 这里演示的是去重功能
{orange, banana, pear, apple}orange in basket # 快速判断元素是否在集合内
Truecrabgrass in basket
False # 下面展示两个集合间的运算.
...a set(abracadabra)b set(alacazam)a
{a, r, b, c, d}a - b # 集合a中包含而集合b中不包含的元素
{r, d, b}a | b # 集合a或b中包含的所有元素
{a, c, r, d, b, m, z, l}a b # 集合a和b中都包含了的元素
{a, c}a ^ b # 不同时包含于a和b的元素
{r, d, b, m, z, l}类似列表推导式同样集合支持集合推导式(Set comprehension):
a {x for x in abracadabra if x not in abc}a
{r, d}11-1 集合的基本操作
11-1-1 添加元素
语法格式如下
s.add( x )将元素 x 添加到集合 s 中如果元素已存在则不进行任何操作。
thisset set((Google, Runoob, Taobao))thisset.add(Facebook)print(thisset)
{Taobao, Facebook, Google, Runoob}还有一个方法也可以添加元素且参数可以是列表元组字典等语法格式如下
s.update( x )x 可以有多个用逗号分开。
thisset set((Google, Runoob, Taobao))thisset.update({1,3})print(thisset)
{1, 3, Google, Taobao, Runoob}thisset.update([1,4],[5,6]) print(thisset)
{1, 3, 4, 5, 6, Google, Taobao, Runoob}11-1-2 移除元素
语法格式如下
s.remove( x )将元素 x 从集合 s 中移除如果元素不存在则会发生错误。
thisset set((Google, Runoob, Taobao))thisset.remove(Taobao)print(thisset)
{Google, Runoob}thisset.remove(Facebook) # 不存在会发生错误
Traceback (most recent call last):File stdin, line 1, in module
KeyError: Facebook此外还有一个方法也是移除集合中的元素且如果元素不存在不会发生错误。格式如下所示
s.discard( x )thisset set((Google, Runoob, Taobao))thisset.discard(Facebook) # 不存在不会发生错误print(thisset)
{Taobao, Google, Runoob}我们也可以设置随机删除集合中的一个元素语法格式如下
s.pop() thisset set((Google, Runoob, Taobao, Facebook))
x thisset.pop()print(x)输出结果
$ python3 test.py
Runoob多次执行测试结果都不一样。
set 集合的 pop 方法会对集合进行无序的排列然后将这个无序排列集合的左面第一个元素进行删除。
11-1-3 计算集合元素个数
语法格式如下
len(s)计算集合 s 元素个数。
thisset set((Google, Runoob, Taobao))len(thisset)
311-1-4 清空集合
语法格式如下
s.clear()清空集合 s。
thisset set((Google, Runoob, Taobao))thisset.clear()print(thisset)
set()11-1-5 判断元素是否在集合中存在
语法格式如下
x in s判断元素 x 是否在集合 s 中存在返回 True不存在返回 False。
thisset set((Google, Runoob, Taobao))Runoob in thisset
TrueFacebook in thisset
False11-2 集合内置方法完整列表 12Python3 编程第一步
在前面的教程中我们已经学习了一些 Python3 的基本语法知识下面我们尝试来写一个斐波纳契数列。
#!/usr/bin/python3# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b 0, 1
while b 10:print(b)a, b b, ab其中代码 a, b b, ab 的计算方式为先计算右边表达式然后同时赋值给左边等价于
nb
mab
an
bm执行以上程序输出结果为
1
1
2
3
5
8这个例子介绍了几个新特征。
第一行包含了一个复合赋值变量 a 和 b 同时得到新值 0 和 1。最后一行再次使用了同样的方法可以看到右边的表达式会在赋值变动之前执行。右边表达式的执行顺序是从左往右的。
输出变量值: i 256*256print(i 的值为, i)
i 的值为 65536end 关键字
关键字end可以用于将结果输出到同一行或者在输出的末尾添加不同的字符实例如下
#!/usr/bin/python3# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b 0, 1
while b 1000:print(b, end,)a, b b, ab执行以上程序输出结果为
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,13Python3 条件控制
13-1 if 语句
Python中if语句的一般形式如下所示
if condition_1:statement_block_1
elif condition_2:statement_block_2
else:statement_block_3如果 “condition_1” 为 True 将执行 “statement_block_1” 块语句如果 “condition_1” 为False将判断 “condition_2”如果condition_2 为 True 将执行 “statement_block_2” 块语句如果 “condition_2” 为False将执行statement_block_3块语句
Python 中用 elif 代替了 else if所以if语句的关键字为if – elif – else。
注意
1、每个条件后面要使用冒号 :表示接下来是满足条件后要执行的语句块。2、使用缩进来划分语句块相同缩进数的语句在一起组成一个语句块。3、在Python中没有switch – case语句。
以下是一个简单的 if 实例
#!/usr/bin/python3var1 100
if var1:print (1 - if 表达式条件为 true)print (var1)var2 0
if var2:print (2 - if 表达式条件为 true)print (var2)
print (Good bye!)执行以上代码输出结果为
1 - if 表达式条件为 true
100
Good bye!从结果可以看到由于变量 var2 为 0所以对应的 if 内的语句没有执行。
以下实例演示了狗的年龄计算判断
#!/usr/bin/python3age int(input(请输入你家狗狗的年龄: ))
print()
if age 0:print(你是在逗我吧!)
elif age 1:print(相当于 14 岁的人。)
elif age 2:print(相当于 22 岁的人。)
elif age 2:human 22 (age -2)*5print(对应人类年龄: , human)### 退出提示
input(点击 enter 键退出)将以上脚本保存在dog.py文件中并执行该脚本
$ python3 dog.py
请输入你家狗狗的年龄: 1相当于 14 岁的人。
点击 enter 键退出以下为if中常用的操作运算符: #!/usr/bin/python3# 程序演示了 操作符
# 使用数字
print(5 6)
# 使用变量
x 5
y 8
print(x y)以上实例输出结果
False
Falsehigh_low.py文件演示了数字的比较运算
#!/usr/bin/python3 # 该实例演示了数字猜谜游戏
number 7
guess -1
print(数字猜谜游戏!)
while guess ! number:guess int(input(请输入你猜的数字))if guess number:print(恭喜你猜对了)elif guess number:print(猜的数字小了...)elif guess number:print(猜的数字大了...)执行以上脚本实例输出结果如下
$ python3 high_low.py
数字猜谜游戏!
请输入你猜的数字1
猜的数字小了...
请输入你猜的数字9
猜的数字大了...
请输入你猜的数字7
恭喜你猜对了13-2 if 嵌套
在嵌套 if 语句中可以把 if…elif…else 结构放在另外一个 if…elif…else 结构中。
if 表达式1:语句if 表达式2:语句elif 表达式3:语句else:语句
elif 表达式4:语句
else:语句# !/usr/bin/python3numint(input(输入一个数字))
if num%20:if num%30:print (你输入的数字可以整除 2 和 3)else:print (你输入的数字可以整除 2但不能整除 3)
else:if num%30:print (你输入的数字可以整除 3但不能整除 2)else:print (你输入的数字不能整除 2 和 3)将以上程序保存到 test_if.py 文件中执行后输出结果为
$ python3 test.py
输入一个数字6
你输入的数字可以整除 2 和 314Python3 循环语句
14-1 while 循环
Python 中 while 语句的一般形式
while 判断条件(condition)执行语句(statements)……同样需要注意冒号和缩进。另外在 Python 中没有 do…while 循环。
以下实例使用了 while 来计算 1 到 100 的总和
#!/usr/bin/env python3n 100sum 0
counter 1
while counter n:sum sum countercounter 1print(1 到 %d 之和为: %d % (n,sum))执行结果如下
1 到 100 之和为: 505014-2 无限循环
我们可以通过设置条件表达式永远不为 false 来实现无限循环实例如下
#!/usr/bin/python3var 1
while var 1 : # 表达式永远为 truenum int(input(输入一个数字 :))print (你输入的数字是: , num)print (Good bye!)执行以上脚本输出结果如下
输入一个数字 :5
你输入的数字是: 5
输入一个数字 :你可以使用 CTRLC 来退出当前的无限循环。
无限循环在服务器上客户端的实时请求非常有用。
14-3 while 循环使用 else 语句
在 while … else 在条件语句为 false 时执行 else 的语句块。
语法格式如下
while expr:statement(s)
else:additional_statement(s)循环输出数字并判断大小
#!/usr/bin/python3count 0
while count 5:print (count, 小于 5)count count 1
else:print (count, 大于或等于 5)执行以上脚本输出结果如下
0 小于 5
1 小于 5
2 小于 5
3 小于 5
4 小于 5
5 大于或等于 514-4 简单语句组
类似if语句的语法如果你的while循环体中只有一条语句你可以将该语句与while写在同一行中 如下所示
#!/usr/bin/pythonflag 1while (flag): print (欢迎访问菜鸟教程!)print (Good bye!)**注意**以上的无限循环你可以使用 CTRLC 来中断循环。
执行以上脚本输出结果如下
欢迎访问菜鸟教程!
欢迎访问菜鸟教程!
欢迎访问菜鸟教程!
欢迎访问菜鸟教程!
欢迎访问菜鸟教程!
……14-5 for 语句
Python for循环可以遍历任何序列的项目如一个列表或者一个字符串。
for循环的一般格式如下
for variable in sequence:statements
else:statementslanguages [C, C, Perl, Python] for x in languages:
... print (x)
...
C
C
Perl
Python以下 for 实例中使用了 break 语句break 语句用于跳出当前循环体
#!/usr/bin/python3sites [Baidu, Google,Runoob,Taobao]
for site in sites:if site Runoob:print(菜鸟教程!)breakprint(循环数据 site)
else:print(没有循环数据!)
print(完成循环!)执行脚本后在循环到 Runoob时会跳出循环体
循环数据 Baidu
循环数据 Google
菜鸟教程!
完成循环!14-6 range()函数
如果你需要遍历数字序列可以使用内置range()函数。它会生成数列例如:
for i in range(5):
... print(i)
...
0
1
2
3
4你也可以使用range指定区间的值
for i in range(5,9) :print(i)5
6
7
8也可以使range以指定数字开始并指定不同的增量(甚至可以是负数有时这也叫做’步长’):
for i in range(0, 10, 3) :print(i)0
3
6
9负数
for i in range(-10, -100, -30) :print(i)-10
-40
-70您可以结合range()和len()函数以遍历一个序列的索引,如下所示:
a [Google, Baidu, Runoob, Taobao, QQ]for i in range(len(a)):
... print(i, a[i])
...
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ还可以使用range()函数来创建一个列表
list(range(5))
[0, 1, 2, 3, 4]14-7 break 和 continue 语句及循环中的 else 子句
break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止任何对应的循环 else 块将不执行。continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句然后继续进行下一轮循环。
while 中使用 break
n 5
while n 0:n - 1if n 2:breakprint(n)
print(循环结束。)输出结果为
4
3
循环结束。while 中使用 continue
n 5
while n 0:n - 1if n 2:continueprint(n)
print(循环结束。)输出结果为
4
3
1
0
循环结束。更多实例如下
#!/usr/bin/python3for letter in Runoob: # 第一个实例if letter b:breakprint (当前字母为 :, letter)var 10 # 第二个实例
while var 0: print (当期变量值为 :, var)var var -1if var 5:breakprint (Good bye!)执行以上脚本输出结果为
当前字母为 : R
当前字母为 : u
当前字母为 : n
当前字母为 : o
当前字母为 : o
当期变量值为 : 10
当期变量值为 : 9
当期变量值为 : 8
当期变量值为 : 7
当期变量值为 : 6
Good bye!以下实例循环字符串 Runoob碰到字母 o 跳过输出
#!/usr/bin/python3for letter in Runoob: # 第一个实例if letter o: # 字母为 o 时跳过输出continueprint (当前字母 :, letter)var 10 # 第二个实例
while var 0: var var -1if var 5: # 变量为 5 时跳过输出continueprint (当前变量值 :, var)
print (Good bye!)执行以上脚本输出结果为
当前字母 : R
当前字母 : u
当前字母 : n
当前字母 : b
当前变量值 : 9
当前变量值 : 8
当前变量值 : 7
当前变量值 : 6
当前变量值 : 4
当前变量值 : 3
当前变量值 : 2
当前变量值 : 1
当前变量值 : 0
Good bye!循环语句可以有 else 子句它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行但循环被 break 终止时不执行。
如下实例用于查询质数的循环例子:
#!/usr/bin/python3for n in range(2, 10):for x in range(2, n):if n % x 0:print(n, 等于, x, *, n//x)breakelse:# 循环中没有找到元素print(n, 是质数)执行以上脚本输出结果为
2 是质数
3 是质数
4 等于 2 * 2
5 是质数
6 等于 2 * 3
7 是质数
8 等于 2 * 4
9 等于 3 * 314-8 pass 语句
Python pass是空语句是为了保持程序结构的完整性。
pass 不做任何事情一般用做占位语句如下实例
while True:
... pass # 等待键盘中断 (CtrlC)最小的类:
class MyEmptyClass:
... pass以下实例在字母为 o 时 执行 pass 语句块:
#!/usr/bin/python3for letter in Runoob: if letter o:passprint (执行 pass 块)print (当前字母 :, letter)print (Good bye!)执行以上脚本输出结果为
当前字母 : R
当前字母 : u
当前字母 : n
执行 pass 块
当前字母 : o
执行 pass 块
当前字母 : o
当前字母 : b
Good bye!15Python3 迭代器与生成器
15-1 迭代器
15-1-1 基础知识
1迭代器迭代取值的工具迭代是重复的过程每一次重复都是基于上次的结果而继续的单纯的重复不是迭代
# 可迭代对象 但凡内置有__iter__()方法的都称之为可迭代对象
# 字符串---列表---元祖---字典---集合---文件操作 都是可迭代对象# 调用可迭代对象下的__iter__方法将其转换为可迭代对象
d {a:1, b:2, c:3}d_iter d.__iter__() # 把字典d转换成了可迭代对象# d_iter.__next__() # 通过__next__()方法可以取值print(d_iter.__next__()) # a
print(d_iter.__next__()) # b
print(d_iter.__next__()) # c# 没值了以后就会报错 抛出异常StopIteration
#-----------------------------------------------
d {a:1, b:2, c:3}
d_iter d.__iter__()
while True:try:print(d_iter.__next__())except StopIteration:break
# 对同一个迭代器对象取值取干净的情况下第二次取值的时候去不了没值只能造新的迭代器15-1-2 迭代器与for循环工作原理
#可迭代对象与迭代器详解#可迭代对象内置有__iter__() 方法对象# 可迭代对象.__iter__(): 得到可迭代对象#迭代器对象内置有__next__() 方法# 迭代器对象.__next__()得到迭代器的下一个值# 迭代器对象.__iter__(): 得到的值迭代器对象的本身调跟没调一个样----------- 为了保证for循环的工作# for循环工作原理d {a:1, b:2, c:3}d_iter d.__iter__()# 1d.__iter__() 方法得到一个跌倒器对象# 2,迭代器对象的__next__()方法拿到返回值将该返回值赋值给k# 3,循环往复步骤2直到抛出异常for循环会捕捉异常并结束循坏for k in d:print(k)# 可迭代器对象不一定是迭代器对象------------迭代器对象一定是可迭代对象# 字符串---列表---元祖---字典---集合只是可迭代对象不是迭代器对象、# 文件操作时迭代器对象也是可迭代对象15-2 生成器本质就是迭代器
# 函数里包含yield,并且调用函数以后就能得到一个可迭代对象
def test():print(第一次)yield 1print(第二次)yield 2print(第三次)yield 3print(第四次)g test()
print(g) # generator object test at 0x0000014C809A27A0
g_iter g.__iter__()
res1 g_iter.__next__() # 第一次
print(res1) # 1
res2 g_iter.__next__() # 第二次
print(res2) # 2
res3 g_iter.__next__() # 第三次
print(res3) # 3 # 补充
len(s) ------- s.__len__()
next(s) ------ s.__next__()
iter(d) ------- d.__iter__()15-2-1 yield 表达式
def person(name):print(%s吃东西啦%name)while True:x yield Noneprint(%s吃东西啦---%s%(name,x))g person(aini)
# next(g) g.send(None)
next(g)
next(g)
# send()方法可以给yield传值
# 不能在第一次运行时用g.send()来传值需要用g.send(None)或者next(g) 来初始化第二次开始可以用g.send(值)来传值
g.send(雪糕) # aini吃东西啦---雪糕
g.send(西瓜) # aini吃东西啦---西瓜15-2-2 三元表达式
x 10
y 20
res x if x y else y
# 格式
条件成立时返回的值 if 条件 else 条件不成立时返回的值15-2-3 列表生成式
l [aini_aaa,dilnur_aaa,donghua_aaa,egon]
res [name for name in l if name.endswith(aaa)]
print(res)# 语法 [结果 for 元素 in 可迭代对象 if 条件]l [aini_aaa,dilnur_aaa,donghua_aaa,egon]
l [name.upper() for name in l]
print(l)l [aini_aaa,dilnur_aaa,donghua_aaa,egon]
l [name.replace(_aaa,) for name in l if name.endswith(_aaa)]
print(l)15-2-4 其他生成器——没有元祖生成式——
### 字典生成器
keys [name,age,gender]
res {key: None for key in keys}
print(res) # {name: None, age: None, gender: None}items [(name,aini),(age,22),(gender,man)]
res {k:v for k,v in items}
print(res)## 集合生成器
keys [name,age,gender]
set1 {key for key in keys}## 没有元祖生成器
g (i for i in range(10) if i % 4 0 ) ## 得到的是一个迭代器#### 统计文件字符个数
with open(aini.txt, modert, encoding utf-8) as f:res sum(len(line) for line in f)print(res)15-2-5 二分法
l [-10,-6,-3,0,1,10,56,134,222,234,532,642,743,852,1431]def search_num(num,list):mid_index len(list) // 2if len(list) 0:print(没找到)return Falseif num list[mid_index]:list list[mid_index 1 :]search_num(num,list)elif num list[mid_index]:list list[:mid_index]search_num(num, list)else:print(找到了 , list[mid_index])search_num(743,l)15-2-6 匿名函数与lambdaj
## 定义
res lambda x,y : xy
## 调用
(lambda x,y : xy)(10,20) # 第一种方法
res(10,20) ## 第二种方法##应用场景
salary {aini:20000,aili:50000,dilnur:15000,hahhaha:42568,fdafdaf:7854
}res max(salary ,key lambda x : salary[x])
print(res)16Python3 函数
函数是组织好的可重复使用的用来实现单一或相关联功能的代码段。
函数能提高应用的模块性和代码的重复利用率。你已经知道Python提供了许多内建函数比如print()。但你也可以自己创建函数这被叫做用户自定义函数。 16-1 定义一个函数
你可以定义一个由自己想要功能的函数以下是简单的规则
函数代码块以 def 关键词开头后接函数标识符名称和圆括号 ()。任何传入参数和自变量必须放在圆括号中间圆括号之间可以用于定义参数。函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。函数内容以冒号起始并且缩进。return [表达式] 结束函数选择性地返回一个值给调用方。不带表达式的return相当于返回 None。 语法
Python 定义函数使用 def 关键字一般格式如下
def 函数名参数列表:函数体默认情况下参数值和参数名称是按函数声明中定义的顺序匹配起来的。
让我们使用函数来输出Hello World
def hello() :print(Hello World!) hello()
Hello World!更复杂点的应用函数中带上参数变量:
#!/usr/bin/python3# 计算面积函数
def area(width, height):return width * heightdef print_welcome(name):print(Welcome, name)print_welcome(Runoob)
w 4
h 5
print(width , w, height , h, area , area(w, h))以上实例输出结果
Welcome Runoob
width 4 height 5 area 2016-2 函数调用
定义一个函数给了函数一个名称指定了函数里包含的参数和代码块结构。
这个函数的基本结构完成以后你可以通过另一个函数调用执行也可以直接从 Python 命令提示符执行。
如下实例调用了 printme() 函数
#!/usr/bin/python3# 定义函数
def printme( str ):# 打印任何传入的字符串print (str)return# 调用函数
printme(我要调用用户自定义函数!)
printme(再次调用同一函数)以上实例输出结果
我要调用用户自定义函数!
再次调用同一函数16-3 参数传递
在 python 中类型属于对象变量是没有类型的
a[1,2,3]aRunoob以上代码中[1,2,3] 是 List 类型“Runoob” 是 String 类型而变量 a 是没有类型她仅仅是一个对象的引用一个指针可以是指向 List 类型对象也可以是指向 String 类型对象。
16-4 可更改(mutable)与不可更改(immutable)对象
在 python 中strings, tuples, 和 numbers 是不可更改的对象而 list,dict 等则是可以修改的对象。
**不可变类型**变量赋值 a5 后再赋值 a10这里实际是新生成一个 int 值对象 10再让 a 指向它而 5 被丢弃不是改变a的值相当于新生成了a。**可变类型**变量赋值 la[1,2,3,4] 后再赋值 la[2]5 则是将 list la 的第三个元素值更改本身la没有动只是其内部的一部分值被修改了。
python 函数的参数传递
**不可变类型**类似 c 的值传递如 整数、字符串、元组。如funa传递的只是a的值没有影响a对象本身。比如在 funa内部修改 a 的值只是修改另一个复制的对象不会影响 a 本身。**可变类型**类似 c 的引用传递如 列表字典。如 funla则是将 la 真正的传过去修改后fun外部的la也会受影响
python 中一切都是对象严格意义我们不能说值传递还是引用传递我们应该说传不可变对象和传可变对象。
16-5 python 传不可变对象实例
#!/usr/bin/python3def ChangeInt( a ):a 10b 2
ChangeInt(b)
print( b ) # 结果是 2实例中有 int 对象 2指向它的变量是 b在传递给 ChangeInt 函数时按传值的方式复制了变量 ba 和 b 都指向了同一个 Int 对象在 a10 时则新生成一个 int 值对象 10并让 a 指向它。
16-6 传可变对象实例
可变对象在函数里修改了参数那么在调用这个函数的函数里原始的参数也被改变了。例如
#!/usr/bin/python3# 可写函数说明
def changeme( mylist ):修改传入的列表mylist.append([1,2,3,4])print (函数内取值: , mylist)return# 调用changeme函数
mylist [10,20,30]
changeme( mylist )
print (函数外取值: , mylist)传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下
函数内取值: [10, 20, 30, [1, 2, 3, 4]]
函数外取值: [10, 20, 30, [1, 2, 3, 4]]16-7 函数参数详解
16-7-1 位置参数--------关键字参数---------混合使用
1位置实参:在函数调用阶段 按照从左到有的顺序依次传入的值
# 特点按照顺序与形参一一对应2 关键字参数
# 关键字实参在函数调用阶段按照keyvalue的形式传入的值
# 特点指名道姓给某个形参传值可以完全不参照顺序
def func(x,y):print(x,y)func(y2,x1) # 关键字参数
func(1,2) # 位置参数3混合使用强调# 1、位置实参必须放在关键字实参前def func(x,y):print(x,y)func(1,y2)func(y2,1)# 2、不能能为同一个形参重复传值def func(x,y):print(x,y)func(1,y2,x3)func(1,2,x3,y4)16-7-2 默认参数------位置参数与默认参数混用
4默认参数# 默认形参在定义函数阶段就已经被赋值的形参称之为默认参数# 特点在定义阶段就已经被赋值意味着在调用阶段可以不用为其赋值def func(x,y3):print(x,y)func(x1)func(x1,y44444)def register(name,age,gender男):print(name,age,gender)register(三炮,18)register(二炮,19) register(大炮,19)register(没炮,19,女)5位置形参与默认形参混用强调# 1、位置形参必须在默认形参的左边def func(y2,x): # 错误写法pass# 2、默认参数的值是在函数定义阶段被赋值的准确地说被赋予的是值的内存地址# 示范1m2def func(x,ym): # y2的内存地址print(x,ym3333333333333333333func(1)# 3、虽然默认值可以被指定为任意数据类型但是不推荐使用可变类型# 函数最理想的状态函数的调用只跟函数本身有关系不外界代码的影响m [111111, ]def func(x, ym):print(x, y)m.append(3333333)m.append(444444)m.append(5555)func(1)func(2)func(3)def func(x,y,z,lNone):if l is None:l[]l.append(x)l.append(y)l.append(z)print(l)func(1,2,3)func(4,5,6)new_l[111,222]func(1,2,3,new_l)16-7-3 可变长度的参数
6可变长度的参数*与**的用法# 可变长度指的是在调用函数时传入的值实参的个数不固定# 而实参是用来为形参赋值的所以对应着针对溢出的实参必须有对应的形参来接收6.1 可变长度的位置参数# I*形参名用来接收溢出的位置实参溢出的位置实参会被*保存成元组的格式然后赋值紧跟其后的形参名# *后跟的可以是任意名字但是约定俗成应该是argsdef func(x,y,*z): # z 3,4,5,6print(x,y,z)func(1,2,3,4,5,6)def my_sum(*args):res0for item in args:resitemreturn resresmy_sum(1,2,3,4,)print(res)# II: *可以用在实参中实参中带*先*后的值打散成位置实参def func(x,y,z):print(x,y,z)func(*[11,22,33]) # func(112233)func(*[11,22]) # func(1122)l[11,22,33]func(*l)# III: 形参与实参中都带*def func(x,y,*args): # args(3,4,5,6)print(x,y,args)func(1,2,[3,4,5,6])func(1,2,*[3,4,5,6]) # func(1,2,3,4,5,6)func(*hello) # func(h,e,l,l,o)6.2 可变长度的关键字参数# I**形参名用来接收溢出的关键字实参**会将溢出的关键字实参保存成字典格式然后赋值给紧跟其后的形参名# **后跟的可以是任意名字但是约定俗成应该是kwargsdef func(x,y,**kwargs):print(x,y,kwargs)func(1,y2,a1,b2,c3)# II: **可以用在实参中(**后跟的只能是字典)实参中带**先**后的值打散成关键字实参def func(x,y,z):print(x,y,z)func(*{x:1,y:2,z:3}) # func(x,y,z)func(**{x:1,y:2,z:3}) # func(x1,y2,z3)# 错误func(**{x:1,y:2,}) # func(x1,y2)func(**{x:1,a:2,z:3}) # func(x1,a2,z3)# III: 形参与实参中都带**def func(x,y,**kwargs):print(x,y,kwargs)func(y222,x111,a333,b444)func(**{y:222,x:111,a:333,b:4444})# 混用*与***args必须在**kwargs之前def func(x,*args,**kwargs):print(args)print(kwargs)func(1,2,3,4,5,6,7,8,x1,y2,z3)def index(x,y,z):print(index ,x,y,z)def wrapper(*args,**kwargs): #args(1,) kwargs{z:3,y:2}index(*args,**kwargs)# index(*(1,),**{z:3,y:2})# index(1,z3,y2)wrapper(1,z3,y2) # 为wrapper传递的参数是给index用的16-7-4 函数的类型提示
## : 后面是提示信息可以随意写
def regidter(name:不能写艾尼,age:至少18岁)print(name)print(age)def register(name:str,age:int,hobbies:tuple)-int: # 返回值类型为 intprint(name)print(age)print(hobbies)# 添加提示功能的同时再添加默认值
def register(name:str aini,age:int 18 ,hobbies:tuple)-int: # 返回值类型为 intprint(name)print(age)print(hobbies)17Python3 数据结构
17-1 列表
Python中列表是可变的这是它区别于字符串和元组的最重要的特点一句话概括即列表可以修改而字符串和元组不能。
以下是 Python 中列表的方法 下面示例演示了列表的大部分方法 a [66.25, 333, 333, 1, 1234.5]print(a.count(333), a.count(66.25), a.count(x))
2 1 0a.insert(2, -1)a.append(333)a
[66.25, 333, -1, 333, 1, 1234.5, 333]a.index(333)
1a.remove(333)a
[66.25, -1, 333, 1, 1234.5, 333]a.reverse()a
[333, 1234.5, 1, 333, -1, 66.25]a.sort()a
[-1, 1, 66.25, 333, 333, 1234.5]注意类似 insert, remove 或 sort 等修改列表的方法没有返回值。 17-2 将列表当做堆栈使用
列表方法使得列表可以很方便的作为一个堆栈来使用堆栈作为特定的数据结构最先进入的元素最后一个被释放后进先出。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。例如 stack [3, 4, 5]stack.append(6)stack.append(7)stack
[3, 4, 5, 6, 7]stack.pop()
7stack
[3, 4, 5, 6]stack.pop()
6stack.pop()
5stack
[3, 4]17-3 将列表当作队列使用
也可以把列表当做队列用只是在队列里第一加入的元素第一个取出来但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快然而在列表里插入或者从头部弹出速度却不快因为所有其他的元素都得一个一个地移动。 from collections import dequequeue deque([Eric, John, Michael])queue.append(Terry) # Terry arrivesqueue.append(Graham) # Graham arrivesqueue.popleft() # The first to arrive now leaves
Ericqueue.popleft() # The second to arrive now leaves
Johnqueue # Remaining queue in order of arrival
deque([Michael, Terry, Graham])17-4 列表推导式
列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素用其获得的结果作为生成新列表的元素或者根据确定的判定条件创建子序列。每个列表推导式都在 for 之后跟一个表达式然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组就必须使用括号。这里我们将列表中每个数值乘三获得一个新的列表 vec [2, 4, 6][3*x for x in vec]
[6, 12, 18]现在我们玩一点小花样 [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]这里我们对序列里每一个元素逐个调用某方法 freshfruit [ banana, loganberry , passion fruit ][weapon.strip() for weapon in freshfruit]
[banana, loganberry, passion fruit]我们可以用 if 子句作为过滤器 [3*x for x in vec if x 3]
[12, 18][3*x for x in vec if x 2]
[]以下是一些关于循环和其它技巧的演示 vec1 [2, 4, 6]vec2 [4, 3, -9][x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54][xy for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3][vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]列表推导式可以使用复杂表达式或嵌套函数 [str(round(355/113, i)) for i in range(1, 6)]
[3.1, 3.14, 3.142, 3.1416, 3.14159]17-5 嵌套列表解析
Python的列表还可以嵌套。
以下实例展示了3X4的矩阵列表 matrix [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]以下实例将3X4的矩阵列表转换为4X3列表 [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]以下实例也可以使用以下方法来实现 transposed []for i in range(4):
... transposed.append([row[i] for row in matrix])
...transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]另外一种实现方法 transposed []for i in range(4):
... # the following 3 lines implement the nested listcomp
... transposed_row []
... for row in matrix:
... transposed_row.append(row[i])
... transposed.append(transposed_row)
...transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]17-6 del 语句
使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割或清空整个列表我们以前介绍的方法是给该切割赋一个空列表。例如 a [-1, 1, 66.25, 333, 333, 1234.5]del a[0]a
[1, 66.25, 333, 333, 1234.5]del a[2:4]a
[1, 66.25, 1234.5]del a[:]a
[]也可以用 del 删除实体变量 del a17-7 元组和序列
元组由若干逗号分隔的值组成例如 t 12345, 54321, hello!t[0]
12345t
(12345, 54321, hello!)# Tuples may be nested:
... u t, (1, 2, 3, 4, 5)u
((12345, 54321, hello!), (1, 2, 3, 4, 5))如你所见元组在输出时总是有括号的以便于正确表达嵌套结构。在输入时可能有或没有括号 不过括号通常是必须的如果元组是更大的表达式的一部分
17-8 集合
集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。可以用大括号({})创建集合。注意如果要创建一个空集合你必须用 set() 而不是 {} 后者创建一个空的字典下一节我们会介绍这个数据结构。
以下是一个简单的演示 basket {apple, orange, apple, pear, orange, banana}print(basket) # 删除重复的
{orange, banana, pear, apple}orange in basket # 检测成员
Truecrabgrass in basket
False # 以下演示了两个集合的操作
...a set(abracadabra)b set(alacazam)a # a 中唯一的字母
{a, r, b, c, d}a - b # 在 a 中的字母但不在 b 中
{r, d, b}a | b # 在 a 或 b 中的字母
{a, c, r, d, b, m, z, l}a b # 在 a 和 b 中都有的字母
{a, c}a ^ b # 在 a 或 b 中的字母但不同时在 a 和 b 中
{r, d, b, m, z, l}集合也支持推导式 a {x for x in abracadabra if x not in abc}a
{r, d}17-9 字典
另一个非常有用的 Python 内建数据类型是字典。序列是以连续的整数为索引与此不同的是字典以关键字为索引关键字可以是任意不可变类型通常用字符串或数值。理解字典的最佳方式是把它看做无序的键值对集合。在同一个字典之内关键字必须是互不相同。一对大括号创建一个空的字典{}。
这是一个字典运用的简单例子 tel {jack: 4098, sape: 4139}tel[guido] 4127tel
{sape: 4139, guido: 4127, jack: 4098}tel[jack]
4098del tel[sape]tel[irv] 4127tel
{guido: 4127, irv: 4127, jack: 4098}list(tel.keys())
[irv, guido, jack]sorted(tel.keys())
[guido, irv, jack]guido in tel
Truejack not in tel
False构造函数 dict() 直接从键值对元组列表中构建字典。如果有固定的模式列表推导式指定特定的键值对 dict([(sape, 4139), (guido, 4127), (jack, 4098)])
{sape: 4139, jack: 4098, guido: 4127}此外字典推导可以用来创建任意键和值的表达式词典 {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}如果关键字只是简单的字符串使用关键字参数指定键值对有时候更方便 dict(sape4139, guido4127, jack4098)
{sape: 4139, jack: 4098, guido: 4127}17-10 遍历技巧
在字典中遍历时关键字和对应的值可以使用 items() 方法同时解读出来 knights {gallahad: the pure, robin: the brave}for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave在序列中遍历时索引位置和对应值可以使用 enumerate() 函数同时得到 for i, v in enumerate([tic, tac, toe]):
... print(i, v)
...
0 tic
1 tac
2 toe同时遍历两个或更多的序列可以使用 zip() 组合 questions [name, quest, favorite color]answers [lancelot, the holy grail, blue]for q, a in zip(questions, answers):
... print(What is your {0}? It is {1}..format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.要反向遍历一个序列首先指定这个序列然后调用 reversed() 函数 for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1要按顺序遍历一个序列使用 sorted() 函数返回一个已排序的序列并不修改原值 basket [apple, orange, apple, pear, orange, banana]for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear18Python3 模块
18-1 模块
## 内置模块
## 第三方模块
## 自定义模块## 模块的四种形式
1 使用Python编写的py文件
2 已被编译为共享库或DLL的C或C扩展
3 把一系列模块组织到一起的文件夹文件夹下面有个__init__.py 该文件夹称为包
3 使用C编写并链接到Python解释器的内置模块import foo
## 首次导入模块会发生什么
1执行foo.py
2, 产生foo.py的命名空间
3在当前文件中产生的有一个名字foo,改名字指向2中产生的命名空间## 无论是调用还是修改与源模块为准与调用位置无关## 导入模块规范
1 Python内置模块
2Python第三方模块
3自定义模块## 起别名import foo as f## 自定义模块命名应该纯小写下划线## 可以在函数内导入模块18-2 写模块时测试
# 每个Python文件内置了__name__,指向Python文件名# 当foo.py 被运行时
__name__ __main__# 当foo.py 被当做模块导入时
__name__ ! __main__##### 测试时可以if判断,在foo.py文件中写以下判断
if __name__ __main__ :## 你的测试代码18-3 from xxx import xxx
# from foo import x 发生什么事情
1 产生一个模块的命名空间
2 运行foo.py 产生将运行过程中产生的名字都丢到命名空间去
3 在当前命名空间拿到一个名字改名字指向模块命名空间18-4 从一个模块导入所有
#不太推荐使用
form foo import *
# 被导入模块有个 __all__ []
__all__ [] # 存放导入模块里的所有变量和函数 默认放所有的变量和函数也可以手动修改foo.py__all__ [x,change]x 10def change():global xx 20a 20b 30run.py from foo import * ## * 导入的是foo.py里的 __all__ 列表里的变量和函数print(x)change()print(a) # 会报错因为foo.py 里的 __all__ 列表里没有a变量18-5 sys.path 模块搜索路径优先级
1 内存内置模块
2 从硬盘查找import sys
# 值为一个列表存放了一系列的文件夹
# 其中第一个文件夹是当前执行所在的文件夹
# 第二个文件夹当不存在因为这不是解释器存放的是pycharm添加的
print(sys.path)
# sys.path 里放的就是模块的存放路径查找顺序
[
E:\\Desktop\\python全栈\\模块, E:\\Desktop\\python全栈, D:\\软件\\pycharm\\PyCharm 2021.3.1\\plugins\\python\\helpers\\pycharm_display, D:\\软件\\python\\python310.zip, D:\\软件\\python\\DLLs, D:\\软件\\python\\lib, D:\\软件\\python, C:\\Users\\艾尼-aini\\AppData\\Roaming\\Python\\Python310\\site-packages, D:\\软件\\python\\lib\\site-packages, D:\\软件\\python\\lib\\site-packages\\win32, D:\\软件\\python\\lib\\site-packages\\win32\\lib, D:\\软件\\python\\lib\\site-packages\\Pythonwin, D:\\软件\\pycharm\\PyCharm 2021.3.1\\plugins\\python\\helpers\\pycharm_matplotlib_backend
]18-6 sys.modules 查看内存中的模块
import sys
print(sys.module) # 是一个字典存放导入的模块## 可以判断一个模块是否已经在内存中
print(foo in sys.module)
18-7 编写规范的模块
this module is used to ...... # 第一行文档注释
import sys # 导入需要用到的包
x 1 # 定义全局变量
class foo: # 定义类pass
def test(): #定义函数passif __name__ __main__:pass
