单行注释
python使用井号（#）号表示单行注释的开始，#号后面知道这行结束为止的代码都将被解释器忽略
多行注释
使用三个单引号或三个双引号将注释的内容括起来
#这是一行简单的注释 print('Hello World!') ''' 这个是被三个单括号括起来的注释 ''' """ 这个是被三个双括号括起来的注释 """Python 需要使用标识符给变量命名，其实标识符就是用于给程序中变量、类、 方法命名的符号（简单来说，标识符就是合法的名字）。
Python 语言的标识符必须以字母、下画线(_)开头， 后面可以跟任意数目的字母、数字和下画线(_)。 此处的宇母并不局限于 26 个英文字母，可以包 含中文字符、日文字符等(python3 支持UTF-8)。
Python 语言是区分大小写的，因此 abc 和 Abe 是两个不同的标识符。
Python 使用等号（＝）作为赋值运算符
Python 是弱类型语言，弱类型语言有两个典型特征。
变量无须声明即可直接赋值： 对一个不存在的变量赋值就相当于定义了一个新变量。
变量的数据类型可以动态改变：同一个变量可以一会儿被赋值为整数值， 一会儿被赋值为 字符串。
在使用标识符时，需要注意如下规则。
标识符可以由字母、数字、下画线（_）组成，其中数字不能打头。标识符不能是 Python 关键字，但可以包含关键字。标识符不能包含空格。Python 还包含一系列关键字和内置函数， 一般也不建议使用它们作为变量名 。
如果开发者尝试使用关键字作为变量名 ， Python 解释器会报错。
如果开发者使用内置函数的名字作为变量名， Python 解释器倒不会报错，只是该内置函数 就被这个变量覆盖了，该内置函数就不能使用了 。
Python 关键字
FalseNoneTrueandasassertbreakclasscontinuedefdelelifelseexceptfinallyforfromglobalifimportinislambdamonlocalnotorpassraisereturntrywhilewithyieldpython 内置函数
abs()all()any()basestring()bin()bool()bytearray()callable()chr()classmethod()cmp()compile()complex()delattr()dict()dir()divmod()enumerate()eval()execfile()file()filter()float()format()frozenset()getattr()globals()hasattr()hash()help()hex()id()input()int()isinstance()issubclass()iter()len()list()locals()long()map()max()memoryview()min()next()object()oct()open()ord()pow()print()property()range()raw_input()reduce()reload()repr()reversed()zip()round()set()setattr()slive()sorted()staticmethod()str()sum()super()tuple()type()unichr()unicode()vars()xrange()Zip()__import__()apply()buffer()coerce()intemPython 3 的整型支持各种整数值，不管是小的整数值，还是大的整数值
＃定义变量 a，赋值为 56 a = 56 print(a) ＃为 a 赋值一个大整数 a = 9999999999999999999999 print(a) # type （）函数用于返回变量的类型 print (type (a))Python 的整型支持 None 值（空值）
a = None print(a)Python 的整型数值有 4 种表示形式。
十进制形式： 最普通的整数就是十进制形式的整数。二进制形式：以 0b 或 0B 开头的整数就是二进制形式的整数。八进制形式： 以0o 或 0O开头的整数就是八进制形式的整数（第二个字母是大写或小写的 0）。十六进制形式：以 0x 或0X 开头的整数就是十六进制形式的整数，其中 10～15 分别以 a-f （此处的a～f不区分大小写）来表示。下面代码片段使用了其他进制形式的数。
＃以 0x 或 0X开头的整型数值是十六进制形式的整数 hex_valuel = 0x13 hex_value2 = 0XaF print("hexValuel 的值为："， hex_valuel) print("hexValue2 的值为："， hex_value2) ＃以 0b 或 0B 开头的整型数值是二进制形式的整数 bin_val = 0b111 print('bin_val 的值为：'， bin_ val) bin_val = 0B101 print('bin_val 的值为：'， bin_val) ＃ 以 0o 或 0O 开头的整型数值是八进制形式的整数 oct_val = 0o54 print('oct_val 的值为：'， oct_val) oct_val= 0017 print('ct_val 的值为：'， oct_val)浮点型数值用于保存带小数点的数值， Python 的浮点数有两种表示形式。
十进制形式：这种形式就是平常简单的浮点数，例如 5.12、 512.0、 0.512。浮点数必须包含 一个小数点，否则会被当成整数类型处理。科学计数形式： 例如 5.12e2 、 5.12E2 。Python 要求字符串必须使用引号括起来,单引号和双引号都行.
由于 input（） 函数总会将用户输入的内容放入字符串中，因此用户可 以输入任何内容， input（）函 数总是返回一个字符串。
msg = input("请输入你的值：") print(type(msg)) print(msg)长字符串可以让字符串中包含任何内容，既可包含单引号，也可包含双引号
Python 还允许使用转义字符（＼） 换行符进行转义，转义之后的换行符不会“中断”字符串
s = '''"Let's go fishing", said Mary. "OK, Let's go", said her brother. they walked to a lake''' print(s) s2 ='The quick brown fox \ jumps over the lazy dog' print(s2) num = 20 + 3 / 4 + \ 2 * 3 print(num)原始字符串以“ ”开头 原始宇符串不会把反斜线当成特殊字符。
s1 = r'G:\publish\codes\02\2.4' print(s1) # 原始字符串包含的引号，同样需要转义 s2 = r'"Let\'s go", said Charlie' print(s2) #由于原始字符串中 的反斜线会对 引号进行转义，因此原始字符串的结尾处不能是反斜线一宇衍串结尾处的引 号就被转义了 ，这样就导致字符串不能正确结束。 s3 = r'Good Morning' '\\' print(s3)bytes 对象只负责以宇节（二进制格式）序列来记录数据，至于这些数据到底表示 么内容，完全由程序决定。 如果采用合适的字符集 字符串 可以转换成字节串；反过来，宇节串也可以恢复成对应的字符串
bytes 保存的就是原始的字节（二进制格式）数据，因此 bytes 对象可用于在网络上传输数据 ，也可用于存储各种二进制格式的文件， 比如 图片、音乐等文件
字符串转换成 bytes 有如下 种方式：
如果字符串内容都是 ASCII 字符，则可以通过直接在字符串之前添加b来构建字节串值调用 bytes()函数（其实是 bytes 构造方法）将字符串按指定 符集转换成字节串，如果不指定字符集，默认使用 UTF-8 字符集。调用字符串本身 encode（） 方法将字符串按指定字符集转换成字节串，如果不指定字符集， 默认使用 UTF-8字符集。bytes转换字符串 ：decode()例如，如下程序示范了如何创建字节串。
# 创建一个空的bytes b1 = bytes() # 创建一个空的bytes值 b2 = b'' # 通过b前缀指定hello是bytes类型的值 b3 = b'hello' print(b3) print(b3[0]) print(b3[2:4]) # 调用bytes方法将字符串转成bytes对象 b4 = bytes('我爱Python编程',encoding='utf-8') print(b4) # 利用字符串的encode()方法编码成bytes，默认使用utf-8字符集 b5 = "学习Python很有趣".encode('utf-8') print(b5) # 将bytes对象解码成字符串，默认使用utf-8进行解码。 st = b5.decode('utf-8') print(st) # 学习Python很有趣python支持的转义字符
转义字符说明\b退格符\n换行符\r回车符\t制表符"双引号’单引号\反斜线 s = 'Hello\nCharlie\nGood\nMorning' print(s)输出结果
Hello Charlie Good Morning s2 = '商品名\t\t单价\t\t数量\t\t总价' s3 = 'python\t108\t\t2\t\t316' print(s2) print(s3)输出结果
商品名 单价 数量 总价 python 108 2 216python提供了“%”对各种类型的数据进行格式化输出
price = 108 print("the book's price is %x" % price)这行代码中的print函数包含三个部分，第一部分是格式字符串（相当于字符串的模版），其中包含一个“%s”占位符，它会被第三部分的变量或表达式的值代替。
格式化字符串中包含多个占位符，第三部分也应该提供多个变量，并且使用圆括号将这些变量括起来。
user = "Charli" age = 8 # 格式化字符串有两个占位符，第三部分提供2个变量 print("%s is a %s years old boy" % (user , age))转换说明符
转换说明符说明d,i转换为带符号的十进制形式的整数o转换为带符号的八进制形式的整数x转换为带符号的十六进制形式的整数X转换为带符号的十六进制形式的整数e转换为科学计数法表示的浮点数（e小写）E转换为科学计数法表示的浮点数（E大写）f,F转换为十进制形式的浮点数g智能选择使用f或e格式G智能选择使用F或E格式C转换为单字符（只接受整数或单字符字符串）r使用repr()将变量或表达式转换为字符串s使用str()将变量或表达式转换为字符串 num = -28 print("num is: %6i" % num) print("num is: %6d" % num) print("num is: %6o" % num) print("num is: %6x" % num) print("num is: %6X" % num) print("num is: %6s" % num) num2 = 30 # 最小宽度为0，左边补0 print("num2 is: %06d" % num2) # 最小宽度为6，左边补0，总带上符号 print("num2 is: %+06d" % num2) # 最小宽度为6，右对齐 print("num2 is: %-6d" % num2) my_value = 3.001415926535 # 最小宽度为8，小数点后保留3位 print("my_value is: %8.3f" % my_value) # 最小宽度为8，小数点后保留3位，左边补0 print("my_value is: %08.3f" % my_value) # 最小宽度为8，小数点后保留3位，左边补0，始终带符号 print("my_value is: %+08.3f" % my_value) the_name = "Charlie" # 只保留3个字符 print("the name is: %.3s" % the_name) # 输出Cha # 只保留2个字符，最小宽度10 print("the name is: %10.2s" % the_name)字符串本质上是由多个字符组成，因此允许通过索引来操作字符
python字符串直接在方括号（[]）中使用索引即可获取对应的字符，第一个字符索引为0，第二个为1，倒数第一个为-1
获取一段用（：）
s = 'crazyit.org is very good' # 获取s中索引2处的字符 print(s[2]) # 输出a # 获取s中从右边开始，索引4处的字符 print(s[-4]) # 输出g # 获取s中从索引3处到索引5处（不包含）的子串 print(s[3: 5]) # 输出zy # 获取s中从索引3处到倒数第5个字符的子串 print(s[3: -5]) # 输出zyit.org is very # 获取s中从倒数第6个字符到倒数第3个字符的子串 print(s[-6: -3]) # 输出y g # 获取s中从索引5处到结束的子串 print(s[5: ]) # 输出it.org is very good # 获取s中从倒数第6个字符到结束的子串 print(s[-6: ]) # 输出y good # 获取s中从开始到索引5处的子串 print(s[: 5]) # 输出crazy # 获取s中从开始到倒数第6个字符的子串 print(s[: -6]) #输出crazyit.org is ver # 判断s是否包含'very'子串 print('very' in s) # True print('fkit' in s) # False # 输出s的长度 print(len(s)) # 24 # 输出'test'的长度 print(len('test')) # 4 # 输出s字符串中最大的字符 print(max(s)) # z # 输出s字符串中最小的字符 print(min(s)) # 空格在str类中与大小写相关的常用方法如下。
title()：将每个单词 首字母改为大写lower()：将整个字符串改为小写upper()： 将整个字符串改为大写。 a = 'our domain is crazyit.org' # 每个单词首字母大写 print(a.title()) # 每个单词首字母小写 print(a.lower()) # 每个单词首字母大写 print(a.upper())str 还提供了如下常用的方法来删除空白。
strip():删除字符串前后 空白。strip():删除字符串前面（左边）的空白。rstrip(): 删除字符串后面（右边）的空白。 s = ' this is a puppy ' # 删除左边的空白 print(s.lstrip()) # 删除右边的空白 print(s.rstrip()) # 删除两边的空白 print(s.strip()) # 再次输出s，将会看到s并没有改变 print(s) s2 = 'i think it is a scarecrow' # 删除左边的i、t、o、w字符 print(s2.lstrip('itow')) # 删除右边的i、t、o、w字符 print(s2.rstrip('itow')) # 删除两边的i、t、o、w字符 print(s2.strip('itow'))str 还提供了如下常用的执行查找 、替换等操作的方法
startswith()：判断字符串是否 以指定子串开头。endswith()：判断字符串是否以指定子串结尾find()： 查找指定子串在字符串中出现的位置，如果没有找到指定子串，则返回-1index()： 查找指定子串在字符串中出现的位置，如果没有找到指定子串，则引发ValueError错误。replace()： 使用指定子串替换字符串中的目标子串translate()： 使用指定的翻译映射表对字符串执行替换。 s = 'crazyit.org is a good site' # 判断s是否以crazyit开头 print(s.startswith('crazyit')) # 判断s是否以site结尾 print(s.endswith('site')) # 查找s中'org'的出现位置 print(s.find('org')) # 8 # 查找s中'org'的出现位置 print(s.index('org')) # 8 # 从索引为9处开始查找'org'的出现位置 #print(s.find('org', 9)) # -1 # 从索引为9处开始查找'org'的出现位置 print(s.index('org', 9)) # 引发错误 # 将字符串中所有it替换成xxxx print(s.replace('it', 'xxxx')) # 将字符串中1个it替换成xxxx print(s.replace('it', 'xxxx', 1)) # 定义替换表：97（a）->945（α）,98（b）->945（β）,116（t）->964（τ）, table = {97: 945, 98: 946, 116: 964} print(s.translate(table)) # crαzyit.org is α good sitePython 为str类提供了一个 maketrans()方法，通过该方法可以非常方便地创建翻 译映射表
>>> table = str.maketrans('abt', '123') >>> table {97: 49, 98: 50, 116: 51} >>>Python 还为 str 提供了分割和连接方法
split()： 将字符串按指定分割符分割成多个短语join()：将 多个短 吾连接成字符串 s = 'crazyit.org is a good site' # 使用空白对字符串进行分割 print(s.split()) # 输出 ['crazyit.org', 'is', 'a', 'good', 'site'] # 使用空白对字符串进行分割,最多只分割前2个单词 print(s.split(None, 2)) # 输出 ['crazyit.org', 'is', 'a good site'] # 使用点进行分割 print(s.split('.')) # 输出 ['crazyit', 'org is a good site'] mylist = s.split() # 使用'/'为分割符，将mylist连接成字符串 print('/'.join(mylist)) # 输出 crazyit.org/is/a/good/site # 使用','为分割符，将mylist连接成字符串 print(','.join(mylist)) # 输出 crazyit.org,is,a,good,site位运算符通常在图形、 图像处理和创建设备驱动等底层开发中使用 。 使用位运算符可以直接操作数值的原始 bit 位， 尤其是在使用自定义的协议进行通信时，使用位运算符对原始数据进行编码和解码也非常有效。
位运算符说明&按位与|按位或^按位异或~按位取反<<左位移运算符>>右位移运算符位运算符的运算法则
第一操作数第二操作数按位与按位或按位异或00000010111001111110所有数值在计算机底层都是以二进制形式存在的，原码是直接将一个数值换算成二进制数。
有符号整数的最高位是符号位，符号位为0代表正数， 符号位为1代表负数。
无符号整数则没有符号位，因此无符号整数只能表示 0和正数。
为了方便计算，计算机底层以补码的形式保存所有的整数。 补码的计算规则是：
正数的补码和原码完全相同负数的补码是其反码加1反码是对原码按位取反，只是最高位（符号位）保持不变。
在进行位移运算时，不难友现，左移 n 位就相当于来以 2 的 11 次方，右移 n 位则相当于除以 2 的 n 次方（如果不能整除，实际返回的结果是小于除得结果数值的最大整数的）。不仅如此，进行位移运算只是得到 了 一个新的运算结果，而原来的操作数本身是不会改变的 。
# 将输出1 print(5 & 9) # 将输出13 print(5 | 9) a = -5 # 将输出4 print( ~a) # 将输出12 print(5 ^ 9) # 输出20 print(5 << 2) # 输出-20 print(-5 << 2) b = -5 # 输出-2 print(b >> 2)+＝：对于 x+= y， 即对应于 x = x+y -＝：对于 x -＝ y，即对应于 x= x-y *＝： 对于 x *= y，即对应于 x=x* y /＝： 对于 x /= y，即对应于 x = x /y //＝： 对于 x II= y，即对应于 x = x //y %＝： 对于 x %=y，即对应于 x=x%y **＝： 对于 x **= y，即对应于 x=x **y ＆＝： 对于 x &=y，即对应于 x = x & y |＝： 对于 x|= y，即对应于 x = x I y ^＝：对于 x ^= y， 即对应于 x= x ^ y <<＝：对于 x<<=y，即对应于 x = x << y >>＝：对于 x >>= y，即对应于 x=x<<y
在使用索引范围时，还可指定步长
a = 'abcdefghijklmn' # 获取索引2到索引8的子串，步长为3 print(a[2:8:3]) # 输出cf # 获取索引2到索引8的子串，步长为2 print(a[2:8:2]) # 输出cegbool类型： - True ：表示真 - False ：表示假
比较运算符：
符号说明>大于，正确傅安辉True，错误返回False<小于，正确傅安辉True，错误返回False>=大于或等于，正确傅安辉True，错误返回False<=小于或等于，正确傅安辉True，错误返回False==等于，正确傅安辉True，错误返回False!=不等于，正确傅安辉True，错误返回Falseis判断两个变量引用的对象是否相同，相同Trueis not判断两个变量引用的对象是否不同，不同True # 输出True print("5是否大于 4：", 5 > 4) # 输出False print("3的4次方是否大于等于90.0：", 3 ** 4 >= 90) # 输出True print("20是否大于等于20.0：", 20 >= 20.0) # 输出True print("5和5.0是否相等：", 5 == 5.0) # 输出False print("True和False是否相等：", True == False) # 输出True # True可以当成整数1使用 print("1和True是否相等：", 1 == True) # 输出True # False可以当做整数0使用 print("0和False是否相等：", 0 == False) print(True + False) # 输出1 print(False - True) # 输出-1 import time # 获取当前时间 # == 两个变量数值是否相等 # is 两个变量是否为同一个对象 a = time.gmtime() b = time.gmtime() print(a == b) # a和b两个时间相等，输出True print(a is b) # a和b不是同一个对象，输出False print(id(a)) print(id(b))逻辑运算符用于操作 bool类型的变量、常量或表达式，逻辑运算的返回值也是 bool值。
逻辑运算符
运算符说明and与，两个操作数必须都为True，返回Trueor或，两个操作数中一个为True,返回Truenot非，只有一个操作数，True返回False，False返回True # 直接对False求非运算，将返回True print(not False) # 5>3返回True，20.0大于10，因此结果返回True print(5 > 3 and 20.0 > 10) # 4>=5返回False，"c">"a"返回True。求或后返回True print(4 >= 5 or "c" > "a")三目运算符的规则是：
先对逻辑表达式 expression 求值，如果逻辑表达式返回 True，则执行并返回 True_statements 的值；如果逻辑表达式返回 False， 则执行并返回 False_statements 的值
a = 5 b = 3 st = "a大于b" if a > b else "a不大于b" # 输出"a大于b" print(st) # 输出"a大于b" print("a大于b") if a > b else print("a不大于b") # 第一个返回值部分使用两条语句，逗号隔开 # 每条语句都会执行， 程序返回多条语句的返回值组成的元组 st = print("crazyit"), 'a大于b' if a > b else "a不大于b" print(st) # 第一个返回值部分使用两条语句，分号隔开 # 每条语句都会执行，程序只返回第一条语句的返回值。 st = print("crazyit"); x = 20 if a > b else "a不大于b" print(st) print(x) # 三目运算符的嵌套 c = 5 d = 5 # 下面将输出c等于d print("c大于d") if c > d else (print("c小于d") if c < d else print("c等于d"))判断某个成员是否位于序列中
s = 'crazyit.org' print('it' in s) # True print('it' not in s) # False print('fkit' in s) # False print('fkit' not in s) # TruePython 语言中的大部分运算符也是从左向右结合的， 只有单目运算符、 赋值运算符和三目运算符例外，它们是从右向左结合的，也就是说，它们是从右向左运算的。
乘法和加法是两个可结合的运算符，也就是说，这两个运算符左右两边的操作数可以互换位置而不会影响结果。
运算符的优先级
运算符说明python运算符优先级索引运算符x[index]或 x[index: index2[:index3]]18，19属性访问x.attribute17乘方**16按位取反~15符号运算符+或-14乘除*、/、//、%13加减+、 -12位移>>、 <<11按位与&10按位异或^9按位或|8比较运算符==、!=、>、>=、<、<=7is运算符is、is not6in运算符in 、not in5逻辑非not4逻辑与and3逻辑或or2切片语法
[start : end : step]
不包含 end 元素
a_tuple = ('crazyit', 20, 5.6, 'fkit', -17) # 访问从第2个到倒数第4个（不包含）所有元素 print(a_tuple[1: 3]) # (20, 5.6) # 访问从倒数第3个到倒数第1个（不包含）所有元素 print(a_tuple[-3: -1]) # (5.6, 'fkit') # 访问从第2个到倒数第2个（不包含）所有元素 print(a_tuple[1: -2]) # (20, 5.6) # 访问从倒数第3个到第5个（不包含）所有元素 print(a_tuple[-3: 4]) # (5.6, 'fkit') b_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9) # 访问从第3个到第9个（不包含）、间隔为2的所有元素 print(b_tuple[2: 8: 2]) # (3, 5, 7) # 访问从第3个到第9个（不包含）、间隔为3的所有元素 print(b_tuple[2: 8: 3]) # (3, 6) # 访问从第3个到倒数第2个（不包含）、间隔为3的所有元素 print(b_tuple[2: -2: 2]) # (3, 5, 7)python允许两种赋值方式：
程序把多个值赋给一个变量时，python会自动将多个值封装成元组，这被称为序列封包
程序允许将序列（元组或列表等）直接赋值给多个变量，序列的各个元素会被依次赋值给每个变量（要求序列的元素个数和变量的个数相等） 这称为解包
# 序列封包：将10、20、30封装成元组后赋值给vals vals = 10, 20, 30 print(vals) # (10, 20, 30) print(type(vals)) # <class 'tuple'> print(vals[1]) # 20 a_tuple = tuple(range(1, 10, 2)) # 序列解包: 将a_tuple元组的各元素依次赋值给a、b、c、d、e变量 a, b, c, d, e = a_tuple print(a, b, c, d, e) # 1 3 5 7 9 a_list = ['fkit', 'crazyit'] # 序列解包: 将a_list序列的各元素依次赋值给a_str、b_str变量 a_str, b_str = a_list print(a_str, b_str) # fkit crazyit # 将10、20、30依次赋值给x、y、z x, y, z = 10, 20, 30 print(x, y, z) # 10 20 30 # 将y,z, x依次赋值给x、y、z x, y, z = y, z, x print(x, y, z) # 20 30 10 # first、second保存前2个元素，rest列表包含剩下的元素 # 变量前面加*号，该变量就代表一个列表 first, second, *rest = range(10) print(first) # 0 print(second) # 1 print(rest) # [2, 3, 4, 5, 6, 7, 8, 9] # last保存最后一个元素，begin保存前面剩下的元素 *begin, last = range(10) print(begin) # [0, 1, 2, 3, 4, 5, 6, 7, 8] print(last) # 9 # first保存第一个元素，last保存最后一个元素，middle保存中间剩下的元素 first, *middle, last = range(10) print(first) # 0 print(middle) # [0, 1, 2, 3, 4, 5, 6, 7, 8] print(last) # 9列表的创建
# 1.使用方括号定义列表 my_list = ['crazyit', 20, 'Python'] print(my_list) # 2.python 提供list()函数创建列表 a_tuple = ('crazyit', 20, -1.2) # 将元组转换成列表 a_list = list(a_tuple) print(a_list) # 使用range()函数创建区间（range）对象 a_range = range(1, 5) print(a_range) # range(1, 5) # 将区间转换成列表 b_list = list(a_range) print(b_list) #[1, 2, 3, 4] # 创建区间时还指定步长 c_list = list(range(4, 20, 3)) print(c_list) # [4, 7, 10, 13, 16, 19]元组的创建
# 1.使用方括号定义列表 my_tuple = ('crazyit', 20, 'Python') print(my_tuple) # 2.python 提供了tuple()函数创建元组 a_list = ['crazyit', 20, -1.2] # 将列表转换成元组 a_tuple = tuple(a_list) print(a_tuple) # 使用range()函数创建区间（range）对象 a_range = range(1, 5) print(a_range) # range(1, 5) # 将区间转换成元组 b_tuple = tuple(a_range) print(b_tuple) #[1, 2, 3, 4] # 创建区间时还指定步长 c_tuple = tuple(range(4, 20, 3)) print(c_tuple) # [4, 7, 10, 13, 16, 19]if语句的形式：
# 1 if expression: statements ... # 2. if expression: statements... else: statements... s_age = input("请输入您的年龄:") age = int(s_age) if age > 20 : # 只有当age > 20时，下面用整体缩进的代码块才会执行 # 整体缩进的语句是一个整体，要么一起执行，要么一起不执行 print("年龄已经大于20岁了") print("20岁以上的人应该学会承担责任...")python的pass语句是空语句
s = input("请输入一个整数: ") s = int(s) if s > 5: print("大于5") elif s < 5: # 空语句，相当于占位符 pass else: print("等于5")断言语句和 if 分支有点类似，它用于对一个bool 表达式进行断言，如果该 bool 表达式为True,该程序可以继续向下执行，否则程序会引发 AssertionError 错误
s_age = input("请输入您的年龄:") age = int(s_age) assert 20 < age < 80 print("您输入的年龄在20和80之间")上面 4个部分只是一般分类，并不是每个循环中都非常清晰地分出这4个部分。
while 语法：
[init_statements] while test_expression: body_statements [iteration_atatements] # 循环的初始化条件 count_i = 0 # 当count_i小于10时，执行循环体 while count_i < 10 : print("count:", count_i) # 迭代语句 count_i += 1 print("循环结束!") # 下面是一个死循环 count_i2 = 0 while count_i2 < 10 : print("不停执行的死循环:", count_i2) count_i2 -=1 print("永远无法跳出的循环体") # while循环遍历元组 a_tuple = ('fkit', 'crazyit', 'Charli') i = 0 # 只有i小于len(a_list)，继续执行循环体 while i < len(a_tuple): print(a_tuple[i]) # 根据i来访问元组的元素 i += 1 # while循环遍历列表 src_list = [12, 45, 34,13, 100, 24, 56, 74, 109] a_list = [] # 定义保存整除3的元素 b_list = [] # 定义保存除以3余1的元素 c_list = [] # 定义保存除以3余2的元素 # 只要src_list还有元素，继续执行循环体 while len(src_list) > 0: # 弹出src_list最后一个元素 ele = src_list.pop() # 如果ele % 2不等于0 if ele % 3 == 0 : a_list.append(ele) # 添加元素 elif ele % 3 == 1: b_list.append(ele) # 添加元素 else: c_list.append(ele) # 添加元素 print("整除3:", a_list) print("除以3余1:",b_list) print("除以3余2:",c_list)for-in 循环专门用于遍历范围、列表、元素和字典等可迭代对象包含的元素。 for-in 循环的语法格式：
for 变量 in 字符串|范围|集合等： statements for-in 循环中的变量的值受 for-in 循环控制，该变量将会在每次循环开始时自动被赋值，因此程序不应该在循环中对该变量赋值for-in 循环可用于遍历任何可选代对象。所谓可迭代对象，就是指该对象中包含 __iter__方法，且该方法的返回值对象具有 next()方法。 # 使用 for-in 循环来计算指定整数的阶乘 s_max = input("请输入您想计算的阶乘:") mx = int(s_max) result = 1 # 使用for-in循环遍历范围 for num in range(1, mx + 1): result *= num print(result)字典包含三个方法：
item()：返回字典中所有的键值对的列表keys()：返回字典中所有的key的列表values()：返回字典中所有的value的列表 my_dict = {'语文': 89, '数学': 92, '英语': 80} # 通过items()方法遍历所有key-value对 # 由于items方法返回的列表元素是key-value对，因此要声明两个变量 for key, value in my_dict.items(): print('key:', key) print('value:', value) print('-------------') # 通过keys()方法遍历所有key for key in my_dict.keys(): print('key:', key) # 在通过key获取value print('value:', my_dict[key]) print('-------------') # 通过values()方法遍历所有value for value in my_dict.values(): print('value:', value) # 统计列表中个元素出现的次数 src_list = [12, 45, 3.4, 12, 'fkit', 45, 3.4, 'fkit', 45, 3.4] statistics = {} for ele in src_list: # 如果字典中包含ele代表的key if ele in statistics: # 将ele元素代表出现次数加1 statistics[ele] += 1 # 如果字典中不包含ele代表的key，说明该元素还未出现国 else: # 将ele元素代表出现次数设为1 statistics[ele] = 1 # 遍历dict，打印出各元素的出现次数 for ele, count in statistics.items(): print("%s的出现次数为:%d" % (ele, count))for表达式用于利用其它区间、元组、列表等可迭代对象创建新的列表。 for表达式的语法如下:
[表达式 for 循环计数器 in 可迭代对象]
for表达式与for循环的区别：
在for关键字之前定义一个表达式，该表达式通常会包含循环计数器for表达式没有循环体，因此不需要冒号for表达式最终返回列表,也叫列表推导式 a_range = range(10) # 对a_range执行for表达式 a_list = [x * x for x in a_range] # a_list集合包含10个元素 print(a_list) b_list = [x * x for x in a_range if x % 2 == 0] # b_list集合包含5个元素 print(b_list) # 使用for表达式创建生成器 c_generator = (x * x for x in a_range if x % 2 == 0) # 使用for循环迭代生成器 for i in c_generator: print(i, end='\t') print() d_list = [(x, y) for x in range(5) for y in range(4)] # d_list列表包含20个元素 print(d_list) dd_list = [] for x in range(5): for y in range(4): dd_list.append((x, y)) print(dd_list) e_list = [[x, y, z] for x in range(5) for y in range(4) for z in range(6)] # 3_list列表包含120个元素 print(e_list) src_a = [30, 12, 66, 34, 39, 78, 36, 57, 121] src_b = [3, 5, 7, 11] # 只要y能整除x，就将它们配对在一起 result = [(x, y) for x in src_b for y in src_a if y % x == 0] print(result)把两个或多个列表‘压缩‘成一个zip对象（可迭代）就可以使用一个循环并行遍历多个列表。
若列表的长度不相等 ，以最短的为准
books = ['Kotlin讲义', 'Swift讲义', 'Python讲义'] prices = [79, 69, 89] # 使用zip()函数压缩两个列表，从而实现并行遍历 for book, price in zip(books, prices): print("%s的价格是: %5.2f" % (book, price))接收各种序列参数，返回一个‘反序排列’的迭代器
对参数本身不会产生任何影响
接收序列参数，返回一个新的、排序好的列表 对参数本身不会产生影响
my_list = ['fkit', 'crazyit', 'Charlie', 'fox', 'Emily'] # 通过传入key参数，指定一个函数来生产排序的关键值 # key=len 按字符串长度排序 for s in sorted(my_list, key=len): print(s) # 通过设置reverse参数，可反向排序 print(sorted(my_list, reverse=True))break 结束循环 跳出循环体 对于嵌套循环，break只能结束所在的循环
# # break 跳出循环 exit_flag = False # 外层循环 for i in range(0, 5) : # 内层循环 for j in range(0, 3 ) : print("i的值为: %d, j的值为: %d" % (i, j)) if j == 1 : exit_flag = True # 跳出里层循环 break # 如果exit_flag为True，跳出外层循环 if exit_flag : break # for else 语句 for i in range(0, 10) : print("i的值是: ", i) if i == 2 : # 执行该语句时将结束循环，不执行else语句 break else: print('else块: ', i)结束函数 或方法
def test() : # 外层循环 for i in range(10) : for j in range(10) : print("i的值是: %d, j的值是: %d" % (i , j)) if j == 1 : return print("return后的输出语句") test()定义函数的语法：
def 函数名（形参列表）： //由零到多条可执行语句组成的函数 [return [返回值]] 函数名：语法角度看，只要是合法字符就行，从程序可读性看，函数名应该由一个或多个有意义的单词连缀而成，每个单词的字母全部小写，单词之间使用下划线分割。形参列表：定义函数可接收的参数。多个形参名之间以逗号（,）隔开。return 语句可以显式的返回一个值，返回值可以是有值的变量，也可以是一个表达式。 ## 定义一个函数，声明2个形参 #def my_max(x, y) : # # 定义一个变量z，该变量等于x、y中较大的值 # z = x if x > y else y # # 返回变量z的值 # return z def my_max(x, y) : # 返回一个表达式 return x if x > y else y # 定义一个函数，声明一个形参 def say_hi(name) : print("===正在执行say_hi()函数===") return name + "，您好！" a = 6 b = 9 # 调用my_max()函数，将函数返回值赋值给result变量 result = my_max(a , b) # print("result:", result) # 调用say_hi()函数，直接输出函数的返回值 print(say_hi("孙悟空")) #编写说明文档：把一段字符串放在函数的声明之后，函数体之前，这段字符串将被作为函数的部分，这个文档就是函数的说明文档。
通过 help() 或 __doc__查看函数的说明文档
def my_max(x, y) : ''' 获取两个数值之间较大数的函数。 my_max(x, y) 返回x、y两个参数之间较大的那个 ''' # 定义一个变量z，该变量等于x、y中较大的值 z = x if x > y else y # 返回变量z的值 return z # 使用help()函数查看my_max的帮助文档 help(my_max) print(my_max.__doc__)函数返回多个值，可以将多个值包装成列表之后返回，也可以直接返回。如果是直接返回多个值，python会自动将多个返回值封装成元组。
def sum_and_avg(list): sum = 0 count = 0 for e in list: # 如果元素e是数值 if isinstance(e, int) or isinstance(e, float): count += 1 sum += e return sum, sum / count my_list = [20, 15, 2.8, 'a', 35, 5.9, -1.8] # 获取sum_and_avg函数返回的多个值，多个返回值被封装成元组 tp = sum_and_avg(my_list) #① print(tp) # 使用序列解包来获取多个返回值 s, avg = sum_and_avg(my_list) #② print(s) print(avg)递归函数：在一个函数体内调用它自身。
递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无需循环控制。
递归函数不断调用自身时，必须在某个时刻函数的返回值是固定的 ，不再调用自身，否则会变成无穷递归。
def fn(n) : if n == 0 : return 1 elif n == 1 : return 4 else : # 函数中调用它自身，就是函数递归 return 2 * fn(n - 1) + fn(n - 2) # 输出fn(10)的结果 print("fn(10)的结果是:", fn(10))位置参数：按照形参位置传入的参数值
默认参数：有默认值的参数
可变参数：参数前加*号，该参数可接收多个参数值，多个值被当成元组输入，参数收集 *args
关键字参数：根据参数名传入参数值，一个或多个，多个用**收集，当做字典 ，**kw
命名关键字参数：只接收后面关键字的参数。（,name,age）只接收关键字是name，age的参数
# 定义一个函数 def girth(width , height): print("width: ", width) print("height: ", height) return 2 * (width + height) # 传统调用函数的方式，根据位置传入参数 print(girth(3.5, 4.8)) # 根据关键字参数来传入参数 print(girth(width = 3.5, height = 4.8)) # 使用关键字参数时可交换位置 print(girth(height = 4.8, width = 3.5)) # 部分使用关键字参数，部分使用位置参数 print(girth(3.5, height = 4.8)) # 位置参数必须放在关键字参数之前，下面代码错误 print(girth(width = 3.5, 4.8)) # 为两个参数指定默认值 def say_hi(name = "孙悟空", message = "欢迎来到疯狂软件"): print(name, ", 您好") print("消息是：", message) # 全部使用默认参数 say_hi() # 只有message参数使用默认值 say_hi("白骨精") # 两个参数都不使用默认值 say_hi("白骨精", "欢迎学习Python") # 只有name参数使用默认值 say_hi(message = "欢迎学习Python") say_hi("欢迎学习Python") #say_hi(name="白骨精", "欢迎学习Python") #say_hi("欢迎学习Python" , name="白骨精") say_hi("白骨精", message="欢迎学习Python") say_hi(name="白骨精", message="欢迎学习Python") # 定义一个打印三角形的函数，有默认值的参数必须放在后面 def printTriangle(char, height = 5) : for i in range(1, height + 1) : # 先打印一排空格 for j in range(height - i) : print(' ', end = '') # 再打印一排特殊字符 for j in range(2 * i - 1) : print(char, end = '') print() printTriangle('@', 6) printTriangle('#', height=7) printTriangle(char = '*') # 定义了支持参数收集的函数 def test(a, *books) : print(books) # books被当成元组处理 for b in books : print(b) # 输出整数变量a的值 print(a) # 调用test()函数 test(5 , "疯狂iOS讲义" , "疯狂Android讲义") # 定义了支持参数收集的函数 def test(*books ,num) : print(books) # books被当成元组处理 for b in books : print(b) print(num) # 调用test()函数 test("疯狂iOS讲义", "疯狂Android讲义", num = 20) my_list = ["疯狂Swift讲义", "疯狂Python讲义"] # 将列表的多个元素传给支持参数收集的参数 test(my_list, num = 20) my_tuple= ("疯狂Swift讲义", "疯狂Python讲义") # 将元组的多个元素传给支持参数收集的参数 test(*my_tuple, num = 20) # 定义了支持参数收集的函数 def test(x, y, z=3, *books, **scores) : print(x, y, z) print(books) print(scores) test(1, 2, 3, "疯狂iOS讲义" , "疯狂Android讲义", 语文=89, 数学=94) test(1, 2, "疯狂iOS讲义" , "疯狂Android讲义", 语文=89, 数学=94) test(1, 2, 语文=89, 数学=94) # 逆向收集参数 def test(name, message): print("用户是: ", name) print("欢迎消息: ", message) my_list = ['孙悟空', '欢迎来疯狂软件'] test(*my_list) def foo(name, *nums): print("name参数: ", name) print("nums参数: ", nums) my_tuple = (1, 2, 3) # 使用逆向收集，将my_tuple元组的元素传给nums参数 foo('fkit', *my_tuple) # 使用逆向收集，将my_tuple元组的第一个元素传给name参数，剩下参数传给nums参数 foo(*my_tuple) # 不使用逆向收集，my_tuple元组整体传给name参数 foo(my_tuple) def bar(book, price, desc): print(book, " 这本书的价格是: ", price) print('描述信息', desc) my_dict = {'price': 89, 'book': '疯狂Python讲义', 'desc': '这是一本系统全面的Python学习图书'} # 按逆向收集的方式将my_dict的多个key-value传给bar()函数 bar(**my_dict)获取指定范围内的变量：
globals（）：返回全局范围内所有变量ocals（）：返回当前局部范围内所有变量vars（object）：获取指定对象范围内所有变量，若不传object参数，vars()和locals（）的作用相同 def test (): age = 20 # 直接访问age局部变量 print(age) # 输出20 # 访问函数局部范围的“变量数组” print(locals()) # {'age': 20} # 通过函数局部范围的“变量数组”访问age变量 print(locals()['age']) # 20 # 通过locals函数局部范围的“变量数组”改变age变量的值 locals()['age'] = 12 # 再次访问age变量的值 print('xxx', age) # 依然输出20 # 通过globals函数修改x全局变量 globals()['x'] = 19 x = 5 y = 20 print(globals()) # {..., 'x': 5, 'y': 20} # 在全局访问内使用locals函数，访问的是全局变量的“变量数组” print(locals()) # {..., 'x': 5, 'y': 20} # 直接访问x全局变量 print(x) # 5 # 通过全局变量的“变量数组”访问x全局变量 print(globals()['x']) # 5 # 通过全局变量的“变量数组”对x全局变量赋值 globals()['x'] = 39 print(x) # 输出39 # 在全局范围内使用locals函数对x全局变量赋值 locals()['x'] = 99 print(x) # 输出99 name = 'Charlie' def test (): # 直接访问name全局变量 print(name) # Charlie name = '孙悟空' test() print(name) name = 'Charlie' def test (): # 直接访问name全局变量 print(globals()['name']) # Charlie name = '孙悟空' test() print(name) # Charlie name = 'Charlie' def test (): # 声明name是全局变量，后面的赋值语句不会重新定义局部变量 global name # 直接访问name全局变量 print(name) # Charlie name = '孙悟空' test() print(name) # 孙悟空全局函数：在全局范围内定义函数 局部函数：在函数体内定义的函数
局部函数只能在封闭函数内有效，其封闭函数也可以返回局部函数，以便程序在其他作用域中使用局部函数
# 定义函数，该函数会包含局部函数 vdef get_math_func(type, nn) : # 定义一个计算平方的局部函数 def square(n) : # ① return n * n # 定义一个计算立方的局部函数 def cube(n) : # ② return n * n * n # 定义一个计算阶乘的局部函数 def factorial(n) : # ③ result = 1 for index in range(2, n + 1) : result *= index return result # 调用局部函数 if type == "square" : return square(nn) elif type == "cube": return cube(nn) else: return factorial(nn) print(get_math_func("square", 3)) # 输出9 print(get_math_func("cube", 3)) # 输出27 print(get_math_func("", 3)) # 输出6nonlocal 声明访问赋值语句只是访问该函数所在函数内的局部变量
def foo (): # 局部变量name name = 'Charlie' def bar (): nonlocal name # 访问bar函数所在的foo函数的name局部变量 print(name) # Charlie name = '孙悟空' bar() foo()函数也是一种值，所有函数都是function对象，可以把函数本身赋值给变量，程序也可以通过该变量来调用函数。
# 定义一个计算乘方的函数 def pow(base, exponent) : result = 1 for i in range(1, exponent + 1) : result *= base return result # 将pow函数赋值给my_fun，则my_fun可当成pow使用 my_fun = pow print(my_fun(3 , 4)) # 输出81 # 定义一个计算面积的函数 def area(width, height) : return width * height # 将area函数赋值给my_fun，则my_fun可当成area使用 my_fun = area print(my_fun(3, 4)) # 输出12lambda表达式语法格式：
lambda [parameter_list]: 表达式 lambda表达式必须使用lambda关键字在lambda之后，冒号左边的是参数列表，可以没有参数，也可以多个参数，如果多个参数，用逗号隔开，冒号右边是lambda表达式的返回值lamda表达式只能是单行表达式 def get_math_func(type) : result=1 # 该函数返回的是Lambda表达式 if type == 'square': return lambda n: n * n # ① elif type == 'cube': return lambda n: n * n * n # ② else: return lambda n: (1 + n) * n / 2 # ③ # 调用get_math_func()，程序返回一个嵌套函数 math_func = get_math_func("cube") print(math_func(5)) # 输出125 math_func = get_math_func("square") print(math_func(5)) # 输出25 math_func = get_math_func("other") print(math_func(5)) # 输出15.0 a = lambda x, y: x + y def add(x, y): return x+ y # 传入计算平方的lambda表达式作为参数 x = map(lambda x: x*x , range(8)) print([e for e in x]) # [0, 1, 4, 9, 16, 25, 36, 49] # 传入计算平方的lambda表达式作为参数 y = map(lambda x: x*x if x % 2 == 0 else 0, range(8)) print([e for e in y]) # [0, 0, 4, 0, 16, 0, 36, 0]