03-Python基础语法(下)

二、Python 基础语法.
1.编码
为源码文件指定编码 # -- coding: cp-1252 --
2.python保留字
Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：import keyword;keyword.kwlist
3.注释
Python中单行注释以 # 开头.
多行注释可以用多个 # 号，还有 ‘’’ 和 “”".
4.行与缩进
python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。如:

if True:	#注意,T必须是大写.
    print("true")
    print("真的")
else:
    print("false")

5.多行语句
Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠()来实现多行语句.
在 [], {}, 或 () 中的多行语句，不需要使用反斜杠().例如：

total = item_one + \
        item_two + \
        item_three
total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

6.数字(Number)类型
python中数字有四种类型：整数、布尔型、浮点数和复数。
int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
bool (布尔), 如 True。
float (浮点数), 如 1.23、3E-2
complex (复数), 如 1 + 2j、 1.1 + 2.2j
注意:复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型.
7.字符串(String)
python中单引号和双引号使用完全相同。
使用三引号(’’'或""")可以指定一个多行字符串。
转义符 ‘’
反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示，并不是换行。
按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
字符串可以用 + 运算符连接在一起，用 * 运算符重复。
Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
Python中的字符串不能改变。
Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
字符串的截取的语法格式如下：变量[头下标:尾下标:步长]

a=1
b=2
c=3
print(isinstance(a,int))
print(a)
he=a+b+c
print(he)
print(c-b-a)
print("***************************")
he01=a+\
     b+\
     c
print(he01)
print("***************************")
print("hello")  
print('嗨')  #python中单引号和双引号使用完全相同。
print("***************************")
print("this is \n a dog.")
print(r"this is \n a tiger.")
print("***************************")
str='Runoob'
print(str)
print(str[0:-1])
print(str[0])
print(str[2:4]) #包前不包后.
print(str[2:])
print(str *2)	# 输出字符串两次，也可以写成 print (2 * str) 
print(str+'你好')
#截取字符串的一部分并与其他字段拼接
var1 = 'Hello World!'
print ("已更新字符串 : ", var1[:6] + 'Runoob!')   
#字符串格式化使用与 C 中 sprintf 函数一样的语法。
print("我叫 %s ,今年 %d 岁啦" % ("小明",19))

8.空行
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
记住：空行也是程序代码的一部分。
9.同一行显示多条语句
Python可以在同一行中使用多条语句，语句之间使用分号(;)分割.如:
import sys;x=‘runoob’;sys.stdout.write(x+’\n’)
使用脚本执行以上代码，输出结果为：
runoob
使用交互式命令行执行，输出结果为：

10.多个语句构成代码组
缩进相同的一组语句构成一个代码块，我们称之代码组。
像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。
我们将首行及后面的代码组称为一个子句(clause)。
11.输入与输出
执行下面的程序在按回车键后就会等待用户输入.
input("\n\n按下enter键后退出.")
print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：

x="a";y="b";z="c"
#换行输出
print(x)
print(y)
print("***************************")
#不换行输出
print(x,end=" ")
print(y,end="")
print(z,end="")
print()
print("***************************")
name=input("what is your name:")
sum=100+200
print("hello",name)
print("sum=",sum)
print("***************************")
name=input("please write your name:")
print("hello!",name)

计算两个整数和:

try:
    line = input("请输入两个整数,并用空格隔开!")
    a = line.split()
    print(int(a[0]) + int(a[1]))
except:
    print("您输入的不是整数!")

格式化显示

#如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。
print('{name}网址:{site}'.format(name='菜鸟教程',site='www.runoob.com '))
#位置及关键字参数可以任意的结合.
print('站点列表{0},{1},和{other}'.format('Google','Runoob',other='Taobao',))
#!a (使用 ascii()), !s (使用 str()) 和 !r (使用 repr()) 可以用于在格式化某个值之前对其进行转化
import math
print('常量PI的近似值为:{}.'.format(math.pi))
print('常量PI的近似值为:{!r}.'.format(math.pi))
#可选项 : 和格式标识符可以跟着字段名。 这就允许对值进行更好的格式化。 下面的例子将 Pi 保留到小数点后三位
print('常量PI的近似值为{0:.3f}.'.format(math.pi))
#在 : 后传入一个整数, 可以保证该域至少有这么多的宽度。 用于美化表格时很有用。
table={'Google':1,'Runoob':2,'Taobao':3}
for name,number in table.items():
    print('{0:10} ==> {1:10d}'.format(name,number))
#如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。
print('Runoob:{0[Runoob]:d};Google:{0[Google]:d};Taobao:{0[Taobao]:d}'.format(table))
#也可以通过在 table 变量前使用 ** 来实现相同的功能
print('Runoob:{Runoob:d};Google:{Google:d};Taobao:{Taobao:d}'.format(**table))

读和写文件
open() 将会返回一个 file 对象，基本语法格式如下:
open(filename, mode)
filename：包含了你要访问的文件名称的字符串值。
mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表(https://www.runoob.com/python3/python3-inputoutput.html)。这个参数是非强制的，默认文件访问模式为只读®。
open()中,第一个参数为要打开的文件名。第二个参数描述文件如何使用的字符。 mode 可以是 ‘r’ 如果文件只读, ‘w’ 只用于写 (如果存在同名文件则将被删除), 和 ‘a’ 用于追加文件内容; 所写的任何数据都会被自动增加到末尾. ‘r+’ 同时用于读写。 mode 参数是可选的; ‘r’ 将是默认值。

## 打开一个文件
f=open("C:\\Users\\小白\Desktop\\1.txt","w")
f.write("python是一门非常好的语言.\n是的,,的确非常号!!\n")
f.write("123456789")
f.writelines(['1','3','5','7','9'])
f.write("换行并追加显示到文件中.")
#如果要写入一些不是字符串的东西, 那么将需要先进行转换
value=('www.baidu.com',14)
s=str(value)
f.write(s)
## 关闭打开的文件
f.close()
f1=open("C:\\Users\\小白\Desktop\\1.txt","r")
#f.readline() 会从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。
str1=f1.readline()
'''
区别f.readlines() 将返回该文件中包含的所有行。如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。
'''
print(str1)
print("************************")
"""
为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。
"""
str=f1.read()
print(str)
# 重新设置文件读取指针到开头
f.seek(0, 0)
line = f.readline()
print ("读取的数据为: %s" % (line))
f.close()

其中,open完整的语法格式为：
open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
参数说明:
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener:
12.判断语句：if … else …
经典的判断语句，需要注意的是在 if expression 后面有个冒号，同样在 else 后面也存在冒号。
采用代码缩进和冒号的方式来区分代码之间的层次关系。

score=80
if score>=90:
    print("excellent")
else:
    if score<60:
        print("fail")
    else:
        print("good job")

13.循环语句：for … in
for 循环是一种迭代循环机制，迭代即重复相同的逻辑操作。如果规定循环的次数，我们可以使用 range 函数，它在 for 循环中比较常用。range(11) 代表从 0 到 10，不包括 11，也相当于 range(0,11)，range 里面还可以增加步长，比如 range(1,11,2) 代表的是[1,3,5,7,9]。

for number in range(11):
    print(number)
for num in range(0,11):
    print(num)
print("******************************")
sum=0
for i in range(11):
    sum=sum+i
print("sum=",sum)
print("******************************")
for j in range(0,11,3):
    print(j)
#结合range()和len()函数以遍历一个序列的索引
a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a)):
    print(i,a[i])
#使用range()函数来创建一个列表
print(list(range(5)))

14.循环语句: while
while 循环是条件循环，在 while 循环中对于变量的计算方式更加灵活。因此 while 循环适合循环次数不确定的循环，而 for 循环的条件相对确定，适合固定次数的循环。无限循环你可以使用 CTRL+C 来中断循环。

sum=0
number=1
while number<11:
    sum=sum+number
    number=number+1
print(sum)
# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a=0
b=1
while b < 10:
    print(b)
    a, b = b, a+b

age=int(input("请输入年龄:"))
print(age)
print(type(age))
if age<0:
    print("age小于0")
elif age==1:
    print("age等于1")
elif age<10:
    print("1<age<10")
elif age>11:
    print("age 大于11")
# 该实例演示了数字猜谜游戏
number=7
guess=-1
print("猜数字游戏!")
while guess != number:
    guess=int(input("输入你猜的数字:"))
    if guess==number:
        print("恭喜你猜对啦!")
    elif guess<number:
        print("猜的数字太小了")
    elif guess>number:
        print("猜的数字太大了")
#while 循环使用 else 语句
count=0
while count<5:
    print(count,"小于5")
    count=count+1
else:
    print(count,"大于5")

15.数据类型：列表、元组、字典、集合
15.1.列表：[]
列表是 Python 中常用的数据结构，相当于数组，具有增删改查的功能，我们可以使用 len() 函数获得 lists 中元素的个数；使用 append() 在尾部添加元素，使用 insert() 在列表中插入元素，使用 pop() 删除尾部的元素。可以使用 del 语句来删除列表的的元素.

lists=['a','b','c']
lists=['a','b','c']
list01=[1,2,3]
print(list01)
print(list01 *2)    # 输出两次列表
print(list01[1:]) 
print(lists+list01) # 连接列表
print(lists)
print("lists的元素个数:",len(lists))
lists.insert(0,'mm')
print(lists)
print("lists的元素个数:",len(lists))		#列表元素个数
list01=[1,9,6,8,1,2,3,1]
list02=[99,98,97]
tup01=(5,2,7,6,9)
print(list01)
print("list01的元素个数:",len(list01))
print(max(list01))  #返回列表元素最大值
print(min(list01))  #返回列表元素最小值
print(tup01)
print(list(tup01))  #将元组转换为列表
print(list01.count(1))  #统计某个元素在列表中出现的次数
list01.extend(list02)   #在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
print(list01)
print(list01.index(9))  #从列表中找出某个值第一个匹配项的索引位置
list02.reverse()    #反向列表中元素
print(list02)
list01.sort()   #对原列表进行排序,默认升序.
print(list01)
#reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
list01.sort(reverse=True)
print(list01)
#通过指定列表中的元素排序来输出列表
list03=[(2,3),(5,9),(3,5),(99,1)]
print(list03)
def takeSecond(elem):
    return elem[1]  # 获取列表的第二个元素

list03.sort(key=takeSecond) # 指定第二个元素排序
print(list03)
list04=list03.copy()    #复制列表,并给新的列表名.
print(list04)
lists.pop()
print(lists)
print("***************************")
del lists[0]	#删除第1个元素
print(lists)
'''使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）。'''
a = [-1, 1, 66.25, 333, 333, 1234.5]
print(a)
del a[0]
print (a)
del a[2:4]
print(a)
del a[:]
print(a)
#也可以用 del 删除实体变量.
del a

Python列表脚本操作符:列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

翻转列表数据显示,如下:

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 表示逆向
    inputWords=inputWords[-1::-1]
    # 重新组合字符串
    output = ' '.join(inputWords)
    return output
 
if __name__ == "__main__":
    input=input("please enter something:")
    rw=reverseWords(input)
    print(rw)
    
    input = 'I like runoob'
    rw = reverseWords(input)
    print(rw)
    #注意:Python中的字符串不能改变。所以上述两组代码不能交换位置.

列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。
当然,也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。
列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。
每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。

vec1=[2,4,6]
print("vec1=",vec1)
print([3*x for x in vec1])
print(3*x for x in vec1) #区别上语句.
print([[x,x**2] for x in vec1])
#可以用 if 子句作为过滤器.
print([3*x for x in vec1 if x>3])
print([3*x for x in vec1 if x<2])
vec2=[4,3,-9]
print("vec2=",vec2)
print([x*y for x in vec1 for y in vec2])
print([x+y for x in vec1 for y in vec2])
print([vec1[i] * vec2[i] for i in range(len(vec1))])
#列表推导式可以使用复杂表达式或嵌套函数.
print([str(round(355/113,i)) for i in range(1,6)])
#嵌套列表解析.Python的列表还可以嵌套。
matrix=[[1,2,3,4],[5,6,7,8],[9,10,11,12]]
print(matrix)
print([[row[i] for row in matrix] for i in range(4)])
#也可以使用以下方法来实现.
transposed=[]
for i in range(4):
    transposed.append([row[i] for row in matrix])
print(transposed)

15.2.元组 (tuple)
元组 tuple 和 list 非常类似，但是 tuple 一旦初始化就不能修改。因为不能修改所以没有 append(), insert() ,pop()这样的方法，可以像访问数组一样进行访问，比如 tuples[0]，但不能赋值。
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
string、list 和 tuple 都属于 sequence（序列）。
注意：
1、与字符串一样，元组的元素不能修改。所谓元组的不可变指的是元组所指向的内存中的内容不可变。
2、元组也可以被索引和切片，方法一样。
3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用.
4、元组也可以使用+操作符进行拼接。

tuples=('tom','tony','ming','qing')
print(tuples)
print("tuples的元素个数:",len(tuples))
print(tuples[0])
print(tuples[-1])
print(tuples[1])
tuple01 = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )	#元组中的元素类型也可以不相同.
list01=[4,5,6]
tup01=()
tup02=("123",)
tup03=("123","tom",list01)
print(tup01)
print(tup02)
print(tup03)
list01.append(99)
print(tup03)
tup03=(99,2,1000)
print(tup03)
print(len(tup03))   #计算元组元素个数。
print(max(tup03))   #返回元组中元素最大值。
print(min(tup03))   #返回元组中元素最小值。
list05=["tom","jone","ming","zhen"] 
print(list05)
print(tuple(list05))    #将可迭代系列转换为元组。
tup04 = ('r', 'u', 'n', 'o', 'o', 'b')
print(id(tup04))
tup04 = (1,2,3)   # 内存地址不一样了
print(id(tup04))

15.3.字典 {dictionary}
字典其实就是{key, value}，多次对同一个 key 放入 value，后面的值会把前面的值冲掉，同样字典也有增删改查。增加字典的元素相当于赋值，比如 score[‘zhaoyun’] = 98，删除一个元素使用 pop，查询使用 get，如果查询的值不存在，我们也可以给一个默认值。
键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

dic={}
dic={"year":12} #定义一个dictionary
dic1={'地址':'九里堤',"联系人":"张三"}
print(dic)
print(dic1)
dic1["电话"]="13511111111"    #添加一个元素
print(dic1)
dic1["电话"]="11111111111"
print(dic1)
dic1.pop("电话")  #删除一个元素
print(dic1)
#查看key是否存在
print("火车北站" in dic1)
print("九里堤" in dic1)
print("地址" in dic1)
print("地址009" not in dic1)
#查看一个key对应的值
print(dic1.get("地址","火车北站"))
print(dic1.get("地址",""))
print(dic1.get("地址"))
print(dic1.get("地址111"))
print("***********************************")
dic2={'地址':'九里堤',"联系人":"张三"}
print(dic2)
print(len(dic2))    #计算字典元素个数，即键的总数。
print(str(dic2))    #输出字典，以可打印的字符串表示。
print(type(dic2))
print(dic2.items()) #以列表返回可遍历的(键, 值) 元组数组
print(dic2.keys())  #返回一个迭代器，可以使用 list() 来转换为列表
print(list(dic2.keys()))
print(sorted(dic2.keys()))
dic2.setdefault("电话","135000000000")    #和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
print(dic2)
dic3={}
print(dic3)
dic3.update(dic2)   #把字典dict2的键/值对更新到dict3里
print(dic3)
print(dic3.values())
print(list(dic3.values()))  #字典 values() 方法返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。
dic2.pop("电话")
print(dic2)
dic2.popitem()
print(dic2)

字典（dictionary）是Python中另一个非常有用的内置数据类型。
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。

dic={}
dic={"year":12} #定义一个dictionary
dic1={'地址':'九里堤',"联系人":"张三"}
print(dic)
print(dic1.keys())  # 输出所有键
print(dic1.values())    # 输出所有值
#构造函数 dict() 可以直接从键值对序列中构建字典
aa=dict([('tom',1),('jone',2),('ming',3)])
print(aa)
print("************************************************")
QQ=dict(AA=1,BB=2,CC=3)
print(QQ)
print("************************************************")
bb={x:x**2 for x in (2,4,6,1)}	#字典推导可以用来创建任意键和值的表达式词典
print(bb)
#如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便
print(dict(sape=4139,guido=2127,jack=40998))

注意：
1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 { }。

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print (dict)
print ("dict['Age']: ", dict['Age'])
del dict['Age'] # 删除键 'Age'
print ("dict['Age']: ", dict['Age'])
dict.clear()     # 清空字典
print(dict)
del dict         # 删除字典

遍历技巧.

#在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来.
knights={'gallahad':'the pure','robin':'the brave'}
print(knights)
for k,v in knights.items():
    print(k,v)
#在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到
for i,v in enumerate(['tic','tac','toe']):
    print(i,v)
#同时遍历两个或更多的序列，可以使用 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))
    #也可以print('what is your {}? it is {}'.format(q,a))
#要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数
for i in reversed(range(1,10,2)):
    print(i)
#要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值
basket=['apple','orange','apple','pear','orange','banana']
for f in sorted(set(basket)):
    print(f)

15.4.集合：set
集合 set 和字典 dictory 类似，不过它只是 key 的集合，不存储 value。同样可以增删查，增加使用 add，删除使用 remove，查询看某个元素是否在这个集合里，使用 in。

s=set(['a','b','c'])
print(s)
s=set(['a','b','c'])
s.update([1,2,3])   #添加元素除了add,还有update.参数可以是列表，元组，字典
print(s)
s.update((4,5,6))
print(s)
s.update({"name":"tom","age":100})
print(s)
s.discard("age")    #移除集合中的元素，且如果元素不存在，不会发生错误。
print(s)
s.pop() #随机删除集合中的一个元素
print(s)
print(len(s))
print(99 in s)
s.add('d')
print(s)
s.remove('b')
print(s)
print('d' in s)
print('qq' in s)

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

student = {'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集合:",a) 
print("b集合:",b) 
print(a - b)     # a 和 b 的差集 
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素
#集合也支持推导式
print({x for x in a if x not in 'abc'})
print("*******************************************")
print(a.isdisjoint(b))
print(a.intersection(b))    #返回两个或更多集合中都包含的元素，即交集。返回一个新的集合.
a.intersection_update(b)
print("a集合:",a) 
print("b集合:",b) 
print(a.difference(b))  #difference() 方法用于返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中。
a.difference_update(b)  #方法用于移除两个集合中都存在的元素。
print("a集合:",a) 
print("b集合:",b) 
b.discard("z")  #discard() 方法用于移除指定的集合元素。该方法不同于 remove() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。
print(b)

16.引用模块 / 包：import
import model_name # 导入一个模块
import module_name1,module_name2 # 导入多个模块
from package_name import moudule_name # 导入包中指定模块
from package_name import * # 导入包中所有模块
注意:Python 语言中 import 的使用很简单，直接使用 import module_name 语句导入即可。这里 import 的本质是什么呢？import 的本质是路径搜索。import 引用可以是模块 module，或者包 package。针对 module，实际上是引用一个.py 文件。而针对 package，可以采用 from … import …的方式，这里实际上是从一个目录中引用模块，这时目录结构中必须带有一个 init.py 文件。
如:import 与 from…import
在 python 用 import 或者 from…import 来导入相应的模块。
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *
1.导入 sys 模块

import sys
print('================Python import mode==========================')
print ('命令行参数为:')
for i in sys.argv:
    print (i)
print ('\n python 路径为',sys.path)

2.导入 sys 模块的 argv,path 成员

from sys import argv,path  #  导入特定的成员
print('================python from import===================================')
print('path:',path) # 因为已经导入path成员，所以此处引用时不需要加sys.path

17.Python3 的六个标准数据类型.
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
注意:Python 数字数据类型用于存储数值。数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间。

counter=100 # 整型变量
miles=1000.12   # 浮点型变量
name="tom"  # 字符串
print(counter,miles,name)
#多个变量赋值
a=b=c=1
print(a,b,c)
l,m,n=4,5,"明明"
print(l,m,n)
print("***********************")
p=1
#isinstance 来判断类型
print(isinstance(p,int))
print(isinstance(p,float))
#内置的 type() 函数可以用来查询变量所指的对象类型。
print(type(p))
q=44
print(q)
q+=1	#效果等于q=q+1.其他数值运算也类似.
print(q)
del q
print("***********************")
#数值运算
print(5+4)  # 加法
print(5+4.5)    #在混合计算时，Python会把整型转换成为浮点数。
print(5-4)  # 减法
print(5*4)  # 乘法
print(5/4)  #返回一个浮点数
print(5//4) #返回一个整数
print(5%4)  # 取余 
print(2**4) # 乘方

18.Python位运算符.

19.Python身份运算符.
身份运算符用于比较两个对象的存储单元.

a = 20
b = 20
if ( 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 没有相同的标识")
c=a
print(c)
if ( a is c ):
   print ("1 - a 和 c 有相同的标识")
else:
   print ("1 - a 和 c 没有相同的标识")
# 修改变量 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 有相同的标识")

20.Python成员运算符.

21.Python运算符优先级.
以下表格列出了从最高到最低优先级的所有运算符：

x = True
y = False
z = False
if x or y and z:	#注意:and 拥有更高优先级.
    print("yes")
else:
    print("no")

22.Python 数字类型转换.
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
int(x) 将x转换为一个整数。
float(x) 将x转换到一个浮点数。
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
23.数学函数.

24.随机数函数.

25.三角函数.

26.数学常量.
pi 数学常量 pi（圆周率，一般以π来表示）
e 数学常量 e，e即自然常数（自然常数）。
27.break和continue
break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
27.Python3 迭代器与生成器.
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。
字符串，列表或元组对象都可用于创建迭代器.

list01=[1,2,3,4,5]
it=iter(list01) # 创建迭代器对象
print(it)
print(next(it)) # 依次输出迭代器的下一个元素
print(next(it))
for i in list01:
    print(i,end=",")
print()
for i in it:
    print(i,end=",")

把一个类作为一个迭代器使用需要在类中实现两个方法 iter() 与 next() 。
如果你已经了解的面向对象编程，就知道类都有一个构造函数，Python 的构造函数为 init(), 它会在对象初始化的时候执行。
iter() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 next() 方法并通过 StopIteration 异常标识迭代的完成。
next() 方法（Python 2 里是 next()）会返回下一个迭代器对象。
创建一个返回数字的迭代器，初始值为 1，逐步递增 1.

class MyNumbers:
    def __iter__(self):
        self.a=1
        return self
    def __next__(self):
        x=self.a
        self.a +=1
        return x
myclass=MyNumbers()
myiter=iter(myclass)
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
class MyNumbersT:
    def __iter__(self):
        self.a=1
        return self
    def __next__(self):
        if self.a <= 5:        
            x=self.a
            self.a +=1
            return x
        else:
            raise StopIteration
myclassT=MyNumbersT()
myiterT=iter(myclassT)
for i in myiterT:
    print(i)

在 Python 中，使用了 yield 的函数被称为生成器（generator）。
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。

import sys
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

28.面向对象.
面向对象技术简介
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
方法：类中定义的函数。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。
Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。
对象可以包含任意数量和类型的数据。

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
# 实例化类
p = people('runoob',10,30)
p.speak()
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
s = student('ken',10,60,6)
s.speak()
#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法
#方法重写.
#如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法
class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法.super() 函数是用于调用父类(超类)的一个方法。
#私有变量和公共变量
class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)
counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
# 报错，实例不能访问私有变量.print (counter.__secretCount)
#私有方法和公共方法
class Site:
    def __init__(self, name, url):
        self.name = name       # public
        self.__url = url   # private 
    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)
    def __foo(self):          # 私有方法
        print('这是私有方法')
    def foo(self):            # 公共方法
        print('这是公共方法')
        self.__foo()
x = Site('菜鸟教程', 'www.runoob.com')
x.who()        # 正常输出
x.foo()        # 正常输出
# 报错    x.__foo()      

类的专有方法：
init : 构造函数，在生成对象时调用
del : 析构函数，释放对象时使用
repr : 打印，转换
setitem : 按照索引赋值
getitem: 按照索引获取值
len: 获得长度
cmp: 比较运算
call: 函数调用
add: 加运算
sub: 减运算
mul: 乘运算
truediv: 除运算
mod: 求余运算
pow: 乘方
29.运算符重载.
Python同样支持运算符重载，我们可以对类的专有方法进行重载

class Vector:
    def __init__(self,a,b):
        self.a=a
        self.b=b
    def __str__(self):
        return 'Vector (%d,%d) '%(self.a,self.b)
    def __add__(self,other):
        return Vector(self.a+other.a,self.b+other.b)
v1=Vector(2,10)
v2=Vector(5,-2)
print(v1)
print(v2)
print(v1+v2)

29.函数.
29.1.函数定义.
定义一个由自己想要功能的函数，以下是简单的规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
29.2.可更改(mutable)与不可更改(immutable)对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
29.3.python 函数的参数传递.
不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

#python 传不可变对象实例
def ChangeInt(a):
    a=10
    print(a)
b=2
ChangeInt(b)
print(b)
#传可变对象实例.
#可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。
def changeme(mylist):
    mylist.append([1,2,3,4])
    print("函数内的值:",mylist)
    return
mylist01=[10,20,30]
changeme(mylist01)
print("函数外的值:",mylist01)

调用函数时可使用的正式参数类型：必需参数,关键字参数,默认参数,不定长参数.

#函数参数的使用可以不需要使用指定顺序
def printinfo(name,age):
    print("名字:",name)
    print("年龄:",age)
    return
printinfo(age=50,name="tom")
#加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
def printinfo01(a,*b):
    print(a)
    print(b)
printinfo01(1,2,3,4,5)
#加了两个星号 ** 的参数会以字典的形式导入.
def printinfo02(c,**d):
    print(c)
    print(d)
printinfo02(1,e=2,d=3,f="tom")
#声明函数时，参数中星号 * 可以单独出现.
#如果单独出现星号 * 后的参数必须用关键字传入.
def f(a,b,*,c):
    return a+b+c
print(f(1,2,c=3))      #直接传入,如:f(1,2,3)就会报错.

29.4.匿名函数.
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
lambda 只是一个表达式，函数体比 def 简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
sum=lambda a,b:a+b
print(sum(1,4))
30.模块.
把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。
1、import sys 引入 python 标准库中的 sys.py 模块；这是引入某一模块的方法。
2、sys.argv 是一个包含命令行参数的列表。
3、sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表。

import sys
print('命令行参数如下:')
for i in sys.argv:
    print(i)
print('\n\nPython 路径为:',sys.path,'\n')

31.异常.
以下实例在 try 语句中判断文件是否可以打开，如果打开文件时正常的没有发生异常则执行 else 部分的语句，读取文件内容.

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print('cannot open', arg)
    else:
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

try-finally 语句无论是否发生异常都将执行最后的代码。

try:
    runoob()
except AssertionError as error:
    print(error)
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)
finally:
    print('这句话，无论异常是否发生都会执行。')

raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。

try:
        raise NameError('HiThere')
    except NameError:
        print('An exception flew by!')
        raise

32.命名空间和作用域.
Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问.
global 和 nonlocal关键字.当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。
33.标准库概览.
建议使用 “import os” 风格而非 “from os import *”。这样可以保证随操作系统不同而有所变化的 os.open() 不会覆盖内置函数 open()。在使用 os 这样的大型模块时内置的 dir() 和 help() 函数非常有用.

import os
os.getcwd() ## 返回当前的工作目录
#dir(os)
print(dir(os))
#help(os)
#glob模块提供了一个函数用于从目录通配符搜索中生成文件列表
import glob
print(glob.glob('*.py'))

#字符串正则匹配.re模块为高级字符串处理提供了正则表达式工具。对于复杂的匹配和处理，正则表达式提供了简洁、优化的解决方案:
import  re
print(re.findall(r'\bf[a-z]*','which foot , ball or hand fell fastest'))
print(re.sub(r'(\b[a-z]+) \1',r'\1','cat in the the hat'))
#如果只需要简单的功能，应该首先考虑字符串方法，因为它们非常简单，易于阅读和调试
print('tea for too'.replace('too','two'))

#math模块为浮点运算提供了对底层C函数库的访问:
import math
print(math.cos(math.pi/4))
print(math.log(1024,2))
#random提供了生成随机数的工具
import random
print(random.choice(['apple','pear','banana']))
print(random.sample(range(100),10))
print(random.random())
print(random.randrange(6))

访问互联网.有几个模块用于访问互联网以及处理网络通信协议。其中最简单的两个是用于处理从 urls 接收的数据的 urllib.request 以及用于发送电子邮件的 smtplib.
注意第二个例子需要本地有一个在运行的邮件服务器。

from urllib.request import urlopen
for line in urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):
    line = line.decode('utf-8')  # Decoding the binary data to text.
    if 'EST' in line or 'EDT' in line:  # look for Eastern Time
        print(line)
import smtplib
server = smtplib.SMTP('localhost')
server.sendmail('soothsayer@example.org', 'jcaesar@example.org',
"""To: jcaesar@example.org
... From: soothsayer@example.org
...
... Beware the Ides of March.
""")
server.quit()

日期和时间.datetime模块为日期和时间处理同时提供了简单和复杂的方法。支持日期和时间算法的同时，实现的重点放在更有效的处理和格式化输出。该模块还支持时区处理.

from datetime import date
now=date.today()
print(now)
print(now.strftime("%m-%d-%y.%d %b %Y is a  %A on the %d day of %B."))
birthday=date(1964,7,31)
age=now-birthday
print(age)
print(age.days)

数据压缩.以下模块直接支持通用的数据打包和压缩格式：zlib，gzip，bz2，zipfile，以及 tarfile。
性能度量.有些用户对了解解决同一问题的不同方法之间的性能差异很感兴趣。Python 提供了一个度量工具，为这些问题提供了直接答案。例如，使用元组封装和拆封来交换元素看起来要比使用传统的方法要诱人的多,timeit 证明了现代的方法更快一些。
更多实例见https://www.runoob.com/python3/python3-examples.html.
作业:

#求 1+3+5+7+…+99 的求和
#方法一
he=0
for i in range(1,100,2):
    he=he+i
print("1+3+5+7+...+99=",he)
#方法二
print("1+3+5+7+...+99=",sum(range(1,100,2)))
'''
在 Python 中引用 scikit-learn 库该如何引用？
不是python内置库.采用命令行安装库pip install scikit-learn.
引用库 import scikit-learn.
'''

问题:
1.命令行输入pip提示不是内部或外部命令?
在python安装目录中找得到script文件夹，查看文件夹内部是否存在pip3.exe这个文件。如果没有，在命令行输入：python -m ensurepip 将pip.exe文件下载下来.此时运行python -m pip install scikit-learn命令就可以了.
2.多次提示timeout?
我采用的第二种方法,可以输入如下命令安装.
python -m pip install -i http://pypi.douban.com/simple --trusted-host pypi.douban.com scikit-learn.
详解:
下载失败timeout的情况。出现这种情况有可能是网速慢或者是被限制了。
首先说一下网速慢的问题，这个问题可以有两种方法解决。

1. 让pip有点耐心，增加等待时间，方法是修改pip配置文件，方法如下：
   $ sudo vi ~/.pip/pip.config //linux or MacOS
   timeout = 6000
2. 通过使用镜像网址来代替，方法如下：
   pip install -i http://pypi.douban.com/simple --trusted-host pypi.douban.com numpy
   另外推荐清华大学一个站点：http://e.pypi.python.org
3. 通过修改配置文件增加镜像站点。
   $ sudo vi ~/.pip/pip.config //linux or MacOS
   [global]
   timeout = 6000
   index-url = http://e.pypi.python.org/simple
   trusted-host = pypi.douban.com
   [install]
   use-mirrors = true
   mirrors = http://e.pypi.python.org
   再者说一下被限制的情况（一般发生在公司或者一些保密场所），如果这个在你所处的局域网中有可以访问外网的机子，
   那么恭喜你，你可以做一个代理来实现访问。pip 支持代理，你只需要找一台有外网权限的开发机，然后搭建一个代理服务器，
   然后在pip中使用这个代理就可以了。
   扯远一点，搭建代理服务器的方法参考：https://wiki.python.org/moin/Twisted-Examples
   然后就是使用代理了，方法如下：
   pip install -i http://pypi.douban.com/simple --proxy http://10.11.12.13:8008 numpy
   原文链接：https://blog.csdn.net/xiaoqu001/article/details/78630392