# 基础类型

整数

a=1
1

字符串

# py中‘与“无区别,都是表示字符串
str=''
str=""
# 多行文本
str='''
'''
# 忽略转义字符,如:\n、\t等
str=r'\n'
1
2
3
4
5
6
7
8

浮点数

# 浮点数
f=1.1
1
2

布尔值

b=True #False
1

空值

# py中None表示空未赋值,其它语言用null/nil表示
n=None
1
2

数组

# 一维数组
list=[123]
# 多维数组
list=[[1,2,3],[1,2,3]]
# 数组切片
# 批量生产数组元素
list = [index for index in range(10)]
print(list[:3])
print(list[1:3])
print(list[1:])
print(list[:])
print(list)
1
2
3
4
5
6
7
8
9
10
11
12
13

元组

# 元组初始化后不可修改
tuple=(1,2)
for item in tuple:
    print(item)
1
2
3
4

# 条件判断

if语句

if Ture:
    pass
1
2

模拟三目运算

# py不支持?:运算符,替代方案
value='a' if(True) else "b"
print(value)
1
2
3

# 循环

for循环

for index in range(10)
	print(index)
1
2

while循环

index=10
while index>0:
    print(index)
    index-=1
1
2
3
4

循环终止符

# continue跳过本次循环之后的代码
for index in range(10):
    for jIndex in range(100):
        if(index%/2)continue
        print(index)
# break跳出本次循环
for index in range(10):
    for jIndex in range(100):
        if(index%/2)break
        print(index)
1
2
3
4
5
6
7
8
9
10
11
12

# 运算符

# &&替代方案
True and True
# ||替代方案
True or True
# !替代方案
not True
# 除法运算符
print(12/2) #6.5
# 取整运算符
print(13//2) #6
# 去模/求余
print(13%2) #1
# 不支持++,--
value+=1
value-=1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# dict/set

字典dict

dict={"a":1,"b":2,"a":3}
# 重复的key,使用后则替换前者
print(dict)
# 打印所有key
print(dict.keys())
# 使用get获取值,避免异常
print(dict.get("c"))
# 判断是否存在key
if "a" in dict:
    print(dict["a"])
1
2
3
4
5
6
7
8
9
10
11

去重set

# set是一个没有value的dict
setArr:set=set([])
setArr.add(1)
setArr.add(1)
setArr.add(2)
print(setArr)
1
2
3
4
5
6

# 函数

# 定义参数带默认值的函数
def method1(arg1,arg2=1):
    pass
1
2
3

匿名函数之lambda

method=lambda index:index+1
print(method)
value=method(1)
print(value)
1
2
3
4
5

# 面向对象

类,静态成员(类成员),实例,实例成员

# 定义一个类
class People:
    pass
# python中没有静态类的概念,所谓的静态类指的是类本身,如下:类成员
People.name="姓名"
print(People.name)
# 创建一个实例
people=People()
people.name="hello name!"
# People.name就类似与静态成员,实例成员的变化不影响静态成员的值
print([People.name,people.name])
1
2
3
4
5
6
7
8
9
10
11

属性

python中并不直接支持属性,但是python中提供了其它方式来模拟属性

class People:
    @property
    def name(self):
        self._name
    @name.setter
    def name(self,value):
        self._name=value		
1
2
3
4
5
6
7

可访问性

通过在变量名前加上__双下划线来定义一个私有成员

class People(object):
   	def __init__(self,name):
        self.__name=name
    pass
People().__name="无法访问的变量"
1
2
3
4
5

继承和多态

默认所有的类都继承了object,如上面的People

class People:
    @property
    def name(self):
        self._name
    @name.setter
    def name(self,value):
        self._name=value
    def getName(self):
        return "People:{0}".format(self._name)
# 继承People类
class Student(People):
    def getName(self):
        return "Student:{0}".format(self.name)
    pass
student=Student()
student.name="属性"
print(student.getName())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

多继承与mixin

在其它语言中通常只支持单一的继承关系,如果需要多继承只能通过接口的方式实现。

多继承在某些时候还是很有用的,所以python将多继承定义为mixin功能,字面理解为混入。

# 动物
class Animals:
    pass
# 游泳
class SwimmingMixIn(Animals):
    pass
# 飞
class FlyingMixIn(Animals):
    pass
# 没有会飞的鱼,但是有会游泳的鸟
class Bird(SwimmingMixIn,FlyingMixIn):
    pass
1
2
3
4
5
6
7
8
9
10
11
12

__slots__限定

作为动态语言,python可以在运行时动态的添加属性,在某些情况下为了限制这种特性,所以有了__slots__方法,这个方法可以阻止这一特性。

class People:
    __slots__=('name','age')
People.name="姓名"
# 允许添加
People.test="test"
# 不允许实例方法添加test属性
People().test="test"
print([People.test,People.name])
1
2
3
4
5
6
7
8
9