1. Python3 基本数据类型
Python3 中的6个标准数据类型：
- Number
Python3支持int、float、bool、complex（复数）,可以通过type查询变量所属的数据类型，也可以通过isinstance判断是否所属某类型。例如：
a=20
print(type(a))
>>>
isinstance(a,int)
>>>True
- String
Python使用反斜杠（\）转义特殊字符，如果不想让反斜杠发生转义，在字符前面添加一个r，表示原始字符串。
>>>print('Ru\noob')
Ru
oob
>>>print(r'Ru\noob')
Ru\noob
注意：
- 反斜杠用来转义，使用r可以让反斜杠不发生转义；
- 字符串可以用+连接在一起，用*表示重复；
- 字符串有两种索引方式，从左往右以0开始，从右往左以-1开始；
- 字符串不能改变。
- List
List是使用最频繁的数据类型，可以完成大多数集合类的数据结构实现。List中原色的类型可以不相同，它支持数字、字符串甚至可以包含列表。
list = ['abcd',786,2.23,'runoob',70.2]
tinylist = [123,'runoob']
print(list[1:3])
print(tinylist*2)
print(list+tinylist)
注意：
- List写在方括号之间，元素用逗号隔开；
- 和字符串一样，List可以被索引和切片；
- List可以使用+进行拼接；
- List中的元素是可以改变的。
- Tuple
与列表类似，不同之处在于元祖的元素不能修改。
tuple =('abcd',786,2.23,'runoob',70.2)
tintytuple = (123,'runoob')
print(tuple)
print(tuple+tinytuple)
注意：
- 与字符串一样，元组的元素不能修改；
- 元组也可以被索引和切片，方法一样；
- 注意构造包含 0 或 1 个元素的元组的特殊语法规则；
- 元组也可以使用+操作符进行拼接。
- 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)
print(a - b)
print(a | b)
print(a & b)
print(a ^ b) #a 和 b中不同时存在的元素
输出结果：
{'Tom', 'Rose', 'Jim', 'Mary', 'Jack'}
Rose 在集合中
{'b', 'r', 'c', 'a', 'd'}
{'b', 'r', 'd'}
{'z', 'r', 'b', 'l', 'c', 'm', 'a', 'd'}
{'a', 'c'}
{'b', 'z', 'r', 'l', 'm', 'd'}
- Dictionary
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取的。字典是一种映射类型，字典用{}标识，它是一个无序的j键(key):值(value)的集合。
dict = {}
dict['one'] ="1-我是菜鸟"
dict[2] = "2-菜鸟工具"
tinydict = {'name':'runoob','code':1,'site':'www.runoon.com'}
print(dict['one'])
print(dict[2])
print(tinydict.keys())
print(tinydict.values())
构建字典的三种方式：
dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{x: x**2 for x in (2,4,6)}
dict(Runoob = 1,Google = 2, Taobao = 3)
注意：
- 字典是一种映射类型，它的元素是键值对；
- 字典的关键字必须为不可变类型，且不能重复；
- 创建空字典用
{}
不可变数据：Number、String、Tuple.
可变数据：List、Dictionary、Set.
2. Python3运算符
2.1 算数运算符
+,-,*,/,%(取模),**(a**b为a的b次方)，//(取整除-向下取接近除数的整数)。
2.2 比较运算符
==,!=,>,<,>=,<=.
2.3 赋值运算符
=,+=,-=,*=,/=,%=,**=,//=.
2.4 位运算符
按位运算符是把数字看作二进制来计算的。
&,|,^(异或),~（取反）,<<（左移）,>>（右移）。
2.5 逻辑运算符
bool运算中，0为假，非0为真。
and(布尔与),or(布尔或),not(布尔非)。
2.6 成员运算符
in(如果在指定序列中找到值返回True，否则返回False)；
not in(如果在指定序列中没有找到值返回True，否则返回False)。
2.7 身份运算符
用于比较两个对象的存储单元，即获取对象的内存地址。
is（判断两个标识符是不是引用自一个对象）；
is not(判断两个标识符是不是引用自不同对象)。
>>>a = [1, 2, 3]
>>> b = a
>>> b is a
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True
is与==的区别：
is用于判断两个变量引用对象是否为同一个，==用于判断引用变量的值是否相等。
3. Python3 数字（Number）
在交互模式中，最后被输出的表达式结果被赋值给变量_,例如：
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
3.1 Python常见数学函数
abs(x) #绝对值
ceil(x) #上入整数，math.ceil(4.1) = 5
cmp(x,y) #比较两个值的大小
exp(x) #e的x次幂
fabs(x) #数字的绝对值
floor(x) #数字的下整数
log(x) #math.log(100,10)=2
log10(x) #10为基底的x的对数
max(x1,x2,...) #最大值
min(x1,x2,...) #最小值
modf(x) #返回x的整数部分与小数部分
pow(x,y) #x**y
round(x,n) #x四舍五入保留n位小数
sqrt(x) #x的平方根
3.2 随机数函数
choice(seq) #从序列的元素中随机挑选一个元素
randrange(start,stop,step) #从指定范围内，按指定基数递增的集合中获取一个随机数
random() #随机生成一个实数，在[0,1)范围内
seed() #改变随机数生成器的种子seed
shuffle(lst) #将序列的所有元素随机排序
uniform(x,y) #随机生成下一个实数，在[x,y]范围内
3.3 三角函数及数学常量
一些三角函数在这里不一一列举了
数学常量主要有pi与e。
4. Python3 字符串
字符串定义用''或者""都可。
4.1 字符串格式化
print("我叫 %s 今年 %d 岁"%('小明',10))
一种格式化字符串函数str.format()，增强了字符串格式化的功能。
"{} {}".format("hello","world")
"{0} {1}".format("hello","world")
"{1}{0}{1}".format("hello","world")
print("网站名:{name},地址{url}".format(name="菜鸟教程",url="www.runoob.com"))
#通过字典设置参数
site={"name":"菜鸟教程","url":"www.runnob.com"}
print("网站名：{name},地址{url}".format(**site))
#通过列表索引设置参数
my_list = ['菜鸟教程','www.runoob.com']
print("网站名：{0[0]},地址{0[1]}".format(my_list)) #"0"是必须的
4.2 Python三引号
允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)
4.3 常用函数
capitalize() #将字符串的第一个字符转换为大写
center(width,fillchar)
#返回一个指定的宽度width居中的字符串，fillchar 为填充字符，默认为空格
count(str,beg=0,end=len(string))
#返回str在string中出现的次数，beg和end为指定范围内的次数
encode(encoding="utf-8",errors="strict")
#以 encoding 指定的编码格式编码字符串
endswith(suffix,beg=0,end=len(string))
#string是否以suffix结束，输出true或者false
expandtabs(tabsize=8)
#将string中的tab转化为空格
……
5. Python3 列表
list.append(obj) #添加新的对象
list.count(obj) #统计某个元素在列表中出现的次数
list.extend(seq) #在列表末尾一次性追加另一个序列中的多个值
list.index(obj) #从列表中找出某个值第一个匹配项的索引位置
list.insert(index,obj) #将对象插入列表
list.pop([index=1]) #移除列表中的一个元素，默认最后一个元素，并返回该元素的值
list.remove(obj) #移除列表中某个值的第一个匹配项
list.reverse() #反向列表中的元素
list.sort(key=None,reverse=False) #对原列表进行排序
list.clear() #清空列表
list.copy() #复制列表
6. Python3 元组
元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。
7. Python3 字典
dict = {'name':'Runoob','Age':7,'Class':'First'}
print("dict['Alice']:",dict['Alice'])
一些内置方法：
radiansdict.clear() #删除字典内所有元素
radiansdict.copy() #返回一个字典的浅复制
radiansdict.fromkeys() #创建一个薪资点，键不变，初始值可赋值或者默认none
radiansdict.items() #以列表返回可比案例的（键，值）元素数组
radiansdict.keys() #返回一个迭代器，可以使用list()来转换为列表
……
8. Python3 集合
内置方法：
add() #为集合添加元素
clear() #移除集合中的所有元素
copy() #拷贝一个集合
difference() #返回多个集合的差集
issubset() #判断指定集合是否为该方法参数集合的子集
……
9. 基本语句
9.1 for 循环
其中，for中关于else的一个用法.循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
if site == "Runoob":
print("菜鸟教程!")
break
print("循环数据 " + site)
else:
print("没有循环数据!")
print("完成循环!")
pass是空语句，是为了保持程序结构的完整性。
9.2 迭代器与生成器
9.2.1 迭代器
迭代器是一个可以记住遍历的位置的对象，迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束，迭代器只能往前不会后退。
迭代器有两个基本的方法：iter()和next()。字符串，列表或元组对象都可用于创建迭代器。
list = [1,2,3,4]
it = iter(list)
print(next(it))
print(next(it))
用常规for语句进行遍历：
list = [1,2,3,4]
it = iter(list)
for i in it:
print(i,end=" ")
也可使用next()函数：
import sys
list= [1,2,3,4]
it = iter(list)
while True:
try:
print(next(it))
except StopIteration:
sys.exit()
创建一个迭代器
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))
StopIteration:用来标识迭代的完成。
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration
myclass = MyNumbers()
myiter = iter(myclass)
for x in myiter:
print(x)
9.2.2 生成器
在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()
9.3 函数
9.3.1 不定长参数
- 加了星号
*的参数会以元组（tuple）的形式导入，存放所有未命名的变量参数。
def printinfo(arg1,*vartuple):
print("输出：")
print(arg1)
print(vartuple)
printinfo(70,60,50)
#输出结果
70
(60,50)
- 参数带两个星号
**,会以字典形式导入
# 可写函数说明
def printinfo( arg1, **vardict ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vardict)
# 调用printinfo 函数
printinfo(1, a=2,b=3)
#输出结果
1
{'a':2.'b':3}
9.3.2 匿名函数
使用lambda创建匿名函数，意即不再使用def语句这样标准的形式定义一个函数
sum = lambda arg1,arg2:arg1 + arg2
#调用sum函数
print("相加后的值为：",sum(10,20))
10. 数据结构
10.1 列表
- 将列表作为堆栈使用
stack = [3,4,5]
stack.append(6) #放在栈顶
stack.append(7)
stack.pop() #从栈顶取出
- 将列表作为队列使用，但效率不高。从列表的最后添加或者弹出元素快，可是从列表里插入或者从头部弹出速度不快，因为所有元素都得一个一个移动。
from collection import deque
queue = deque(["Eric","John","Michael"])
queue.append("Terry")
queue.append("Graham")
queue.popleft() #第一个Eric离开
queue.popleft() #第二个John离开
queue #deque(['Michael','Terry','Graham'])
- 列表推导式
>>> 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]
>>> [x+y 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]
10.2 遍历技巧
- 在字典中遍历
knights = {'gallahad':'the pure','robin':'the brave'}
for k,v in knighes.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()组合
question = ['name','quest','favorite coloe']
answers = ['lancelot','the holy grail', 'blue']
for q,a in zip(question,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.
- 反向遍历序列
for i in reversed(range(1,10,2)):
print(i)
#输出结果
9
7
5
3
1
- 按顺序遍历一个序列
basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for f in sorted(set(basket)):
print(f)
#输出结果
apple
banana
orange
pear
11. 输入与输出
- 读取键盘输入
str = input("请输入：")
print(str)
- 读和写文件
open(filename,mode)
# r(读),w（写）,a(追加)
# 打开一个文件
f = open("/tmp/foo.txt", "w")
f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
# 关闭打开的文件
f.close(
open完整的语法格式：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
- 文件对象的方法
f.read() #读取文件中的所有内容
f.readline() #读取文件中的一行
f.readlines() #读取文件中的每一行，并且按行显示
f.write("hello") #向文件中写入字符串，返回写入的字符数
f.tell() #返回文件对象当前所处的位置，从文件开头开始算起的字节数
f.seek(offset,from_what) #改变文件当前的位置
seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
seek(x,1) ： 表示从当前位置往后移动x个字符
seek(-x,2)：表示从文件的结尾往前移动x个字符
f.close() #关闭文件并释放系统资源
12. 面向对象
12.1 类对象
class MyClass:
i = 12345
# __init__()为构造方法，在类实例化时自动调用
def __init__(slef,realpart,imagpart):
self.r = realpart
self.j = imagpart
def f(self):
return 'hello world'
#类的方法与普通的函数只有一个特别的区别，必须有一个额外的第一个参数名称，按照惯例它的名称是self,替换为其他的也OK
def prt(self):
print(self) #self代表的是实例，代表当前对象的地址
print(self.__class_) #指向类
#实例化类
x = MyClass()
print("MyClass 类的属性i为：",x.i)
print("MyClass 类的方法f输出为：",x.f())
print(x.r,x.j)
12.2 类的方法
在类内部，使用def关键字定义一个方法，与一般函数定义不同，类的方法必须包含参数self，且为第一个参数，self代表的是类的实例。
#类定义
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()
12.3 继承
class people:
name = ''
age = 0
#私有属性定义
__weight = 0
#定义构造方法
def __init__(self,n,a,w):
slef.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 说：我 %d 岁。"%(self.name,self.age))
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 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))
#多重继承
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)
s = student('ken',10,60,3)
s.speak()
super(student,s).speak() #用子类对象调用父类已被覆盖的方法
test = sample("Tim",25,80,4,"Python")
test.speak() #方法名同，默认调用的是在括号中排前地父类的方法
12.4 类属性与方法
class JustCounter:
__secretCount = 0 #私有变量
publicCount = 0 #公有变量
def __init__(self,name,url):
self.name = name
self.__url = url
def count(self):
self.secretCount += 1
self.publicCount +=1
print(self.__secretCount)
#私有方法
def __foo(self):
print("this is private method")
def foo(self):
print("this is public method")
self.__foo
counter = JustCounter("cainiao","stardream")
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount) # 报错，实例不能访问私有变量
count.foo() #正常输出
count.__foo() #报错
类的专有方法：
__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__truediv__: 除运算
__mod__: 求余运算
__pow__: 乘方
12.5 运算符重载
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_add(self,other):
return Vector(self.a + other.a,self.b + other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print(v1 + v2)
#输出结果
Vector(7,8)
本文代码均来自菜鸟教程.