python语法简单总结

I. 基本数据类型

1. Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
2. 在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

  counter = 100          # 整型变量
  miles   = 1000.0       # 浮点型变量
  name    = "runoob"     # 字符串

python允许同时多变量赋值

  a = b = c = 1

Python3 中有六个标准的数据类型

• 不可变数据: Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据: List（列表）、Dictionary（字典）、Set（集合）

1. Number数字

Python3 支持 int、float、bool、complex（复数）

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

也可以用isinstance判断数据类型

>>> a = 111
>>> isinstance(a, int)
True

Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0会返回True，但可以通过 is 来判断类型

>>> issubclass(bool, int) 
True
>>> True==1
True
>>> False==0
True
>>> True+1
2
>>> False+1
1
>>> 1 is True
False
>>> 0 is False
False

• 运算符

>>> 5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32

2.String字符串

Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符

• 字符串截取语法格式: 变量[头下标:尾下标]
  索引值以 0 为开始值，-1 为从末尾的开始位置。左闭右开[和java相比多了个从后面索引, 在str[x:y]中前后索引可以混合使用]

3. List列表

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）

list = [ '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) # 连接列表

1、List写在方括号之间，元素用逗号隔开。
2、和字符串一样，list可以被索引和切片。
3、List可以使用+操作符进行拼接。
4、List中的元素是可以改变的。

• Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：
  

letters[索引开始:索引结束:索引步长]

4. Tuple元组

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
元组中的元素类型也可以不相同

tuple = ( '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) # 连接元组
tuple[0] = 1 #报错, tuple元素不能修改
tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

• string、list 和 tuple 都属于 sequence（序列）

5. Set集合

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

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}

print(sites)   # 输出集合，重复的元素被自动去掉
>>> {'Taobao', 'Runoob', 'Google', 'Baidu', 'Zhihu', 'Facebook'}

# 成员测试
if 'Runoob' in sites :
    print('Runoob 在集合中')
else :
    print('Runoob 不在集合中')
>>> Runoob 在集合中

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
>>> {'b', 'c', 'a', 'r', 'd'}
print(a - b)     # a 和 b 的差集
>>> {'r', 'b', 'd'}
print(a | b)     # a 和 b 的并集
>>> {'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
print(a & b)     # a 和 b 的交集
>>> {'c', 'a'}
print(a ^ b)     # a 和 b 中不同时存在的元素
>>> {'z', 'b', 'm', 'r', 'l', 'd'}

6. Dictionary字典

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

dict = {}
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)          # 输出完整的字典
>>> {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
print (tinydict.keys())   # 输出所有键
>>> dict_keys(['name', 'code', 'site'])
print (tinydict.values()) # 输出所有值
>>> dict_values(['runoob', 1, 'www.runoob.com'])

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

II. 数据类型转换

隐式类型转换

num_int = 123
num_flo = 1.23
num_str = "456"
num_new = num_int + num_flo
print(type(num_new))
>>> <class 'float'>
print(num_int+num_str)
>>> TypeError: unsupported operand type(s) for +: 'int' and 'str' # Python中int和string无法隐式转换

显式类型转换

#int() 强制转换为整型
y = int(2.8) # y 输出结果为 2
z = int("3") # z 输出结果为 3

#float() 强制转换为浮点型
x = float(1)     # x 输出结果为 1.0
y = float(2.8)   # y 输出结果为 2.8
z = float("3")   # z 输出结果为 3.0
w = float("4.2") # w 输出结果为 4.2

#str() 强制转换为字符串类型
x = str("s1") # x 输出结果为 's1'
y = str(2)    # y 输出结果为 '2'
z = str(3.0)  # z 输出结果为 '3.0'

整型和字符串类型进行运算，就可以用强制类型转换来完成

III. 推导式

Python 支持各种数据结构的推导式：

• 列表(list)推导式
• 字典(dict)推导式
• 集合(set)推导式
• 元组(tuple)推导式

列表推导式

[表达式 for 变量 in 列表]
[out_exp_res for out_exp in input_list]
或者
[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]

• out_exp_res：列表生成元素表达式，可以是有返回值的函数。
• for out_exp in input_list：迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。
• if condition：条件语句，可以过滤列表中不符合条件的值。

namesList = ['Bob','Tom','alice','Jerry','Wendy','Smith']
newList = [i.upper() for i in namesList if len(i)>3]
print(newList)
>>> ['ALICE', 'JERRY', 'WENDY', 'SMITH']

字典推导式

{ key_expr: value_expr for value in collection if condition }

>>> dic = {x: x**2 for x in (2, 4, 6)}
>>> dic
{2: 4, 4: 16, 6: 36}
>>> type(dic)
<class 'dict'>

集合推导式

{ expression for item in Sequence if conditional }

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'d', 'r'}
>>> type(a)
<class 'set'>

元组推导式（生成器表达式）

元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。
(expression for item in Sequence if conditional )

>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50>  # 返回的是生成器对象

>>> tuple(a)       # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)

IV. 条件控制与循环

条件控制

#if格式:
if guess == number:
        print("恭喜，你猜对了！")
    elif guess < number:
        print("猜的数字小了...")
    elif guess > number:
        print("猜的数字大了...")

#match...case格式: 3.10加的
match http_code:
    case "200":
        print("OK")
        do_something_good()
    case "404":
        print("Not Found")
        do_something_bad()
    case "418":
        print("I'm a teapot")
        make_coffee()
    case _: #case_相当于default
        print("Code not found")

循环

while循环:
while counter <= 10:
    sum = sum + counter
    counter += 1

for循环:
for number in range(1, 6):
    print(number)

V. 函数

python和C++/Java不一样，没有主函数一说，也就是说python语句执行不是从所谓的主函数main开始的。

当运行单个python文件时，如运行a.py，这个时候a的一个属性__name__是__main__。

当调用某个python文件时，如b.py调用a.py，这个时候a的属性__name__是模块名a。

定义函数

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号 : 起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None
  

VI. 面向对象

类的定义及实例化

class TestClass:
    a0 = "testarr0"
    #构造函数
    def __init__(self, in_arr1, in_arr2):
        self.a1 = in_arr1
        self.a2 = in_arr2
    #类的方法
    def printInfo(self):
        print(self.a0, self.a1, self.a2)


if __name__ == "__main__":
    x = TestClass(3.0, -4.5)
    x.printInfo()

继承 单继承与多继承

• 需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，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))
 
#单继承示例
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 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 JustCounter:
    __secretCount = 0  # 两个下划线表示私有变量(方法同理)
    publicCount = 0    # 公开变量
 
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)