Python3 语法（自用）

Python3 基本语法

Python 中，分号可加可不加；但是如果一行中有多个语句，就必须加。

#!/usr/bin/python3

这是为了避免当用户没有将python 装在默认的 /usr/bin 路径里，而找不到python解释器的问题。参考文献。

注释

#!/usr/bin/python3
# 第一个注释
# 第二个注释
'''
第三注释
第四注释
'''
"""
第五注释
第六注释
"""
print ("Hello, Python!")

在 Python 中，' 与 " 完全一致。

跨行语句

print("Hello \
Python!");

取消转义字符

print(r"Hello \nPython!");

使输出不换行

print('1', end="");
print('2');

isinstance：判断变量是不是某种类型

a=1
print(isinstance(a,int));

Python3 基本数据类型

str.split(' ') 和 ' '.join(str)

str.split(' ')：将字符串按照空格分段，转化成 list；
' '.join(str)：将 list 拼接成字符串，相邻两个元素之间用空格隔开。

def reverseWords(input):
    inputWords = input.split(' ')
    inputWords = inputWords[-1::-1]
    output = ' '.join(inputWords)
    return output

if __name__ == '__main__':
    input = 'I like runoob'
    rw = reverseWords(input)
    print(rw)

Dictionary: 字典

key -> value 无序的映射集合。类似于 map，但不要求 key 和 value 的类型分别一致。

dict={}
dict['hello']=1
dict[2]='world'
dt={2:'This is ',1:'another dictionary'}

print(dict['hello']);
print(dict[2]);
print(dt);
print(dt.keys());
print(dt.values());

int() 与 ord()

int() 将数字字符串转换成它表达的数；
ord() 将字符转换为对应的 ASCII 码，相当于C++的 int()；
chr() 将 ASCII 码转换为对应的字符，相当于C++的 char()。

a='5'
b=int(a)
print(b) //output:5
c=ord(a)
print(c) //output:53

Python3 运算符

与C++相比，Python3多了以下运算符。

1. x**y x的y次方，相当于 pow(x, y)。比如 10**3=1000。
2. x//y x除以y，结果向下取整。比如 -9//2=-5，7.5//3.5=2.0。
3. x/y 若 x,y 是实数，则永远返回一个浮点数；否则返回复数（实数部分则不一定是浮点数）。

Python3 数字

数的类型转换：类型(变量)

a=2.9
b=int(a) //b=2

两种方便的随机函数

import random
choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
random() 生成一个 $[0,1)$ 之间的实数。
uniform(x, y) 生成一个 $[x,y)$ 之间的实数。random() 其实就是 uniform(0, 1)。

import module 和 from module import 的区别

1. 用前者的话，调用时用 module.，后者则不用；
2. 如果从 module 里调用变量并修改，则前者会同步修改 module 里的变量（相当于引用），后者则不会（相当于为变量建一个信的复制，然后修改复制）。

Python3 条件控制

if 语句

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

Python3 循环语句

while 语句

while condition:
	statements

Python 中没有 do...while，但是有 while...else:

while condition:
	statement1
else:
	statement2

for 语句

与 C++ 不同的是，python 的 for 只需给出变量的变化范围集合（sequence），而无需给出遍历方式（例如从1到n）。

for <variable> in <sequence>:
    <statements>
else:
    <statements>

比如：

sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    print(site)

word = 'runoob'
for letter in word:
    print(letter)

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

range(st, ed, step) 能生成一个等差数列，范围是 $[st,ed)$，公差是 $step$（不指定则为 1）。

类似也有 for...else。若 for 循环完全执行、中途未被 break，则之后执行 else 后内容；否则不执行后面内容。

for x in range(6):
  print(x)
else:
  print("Finally finished!")

Python3 元组

元组与列表类似，不同之处在于元组的元素不能修改。

>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

元组运算符

a+b 表示首尾相接，a*4 表示 a+a+a+a。此外，元组也可以迭代：

for x in (1, 2, 3): 
    print (x, end=" ")

len(t) 可以求元组 t 的元素个数。

Python3 列表

list.append() 可以在列表末尾插入一个元素，del 可以删除一个元素。

list.append('Baidu')
del list[2]

其余与元组类似。

Python3 集合

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False

>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

set.add(x) 将 x 加入集合 set 中，set.discard(x) 将 x 从集合 set 中删除。
此外，还有 len()、clear()、x in set 等。

Python 推导式

推导式可以用简短的代码描述一类对象，就像数学中的集合的一种定义方法
{ x ∣ 一个推导式 } \{x|一个推导式\} {x∣一个推导式}

推导式有两种格式。

表达式 for 变量 in 列表
表达式 for 变量 in 列表 if 条件

对列表、字典、集合、元组都适用。举例如下：

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

listdemo = ['Google','Runoob', 'Taobao']
# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
>>> newdict = {key:len(key) for key in listdemo}
>>> newdict
{'Google': 6, 'Runoob': 6, 'Taobao': 6}

>>> setnew = {i**2 for i in (1,2,3)}
>>> setnew
{1, 4, 9}

>>> 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)

Python3 函数

def max(a, b):
    if a > b:
        return a
    else:
        return b
 
a = 4
b = 5
print(max(a, b))

可更改 (mutable) 与不可更改 (immutable) 对象

在 python 中，strings, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。

可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身 la 没有动，只是其内部的一部分值被修改了。

python 函数的参数传递

不可变类型：类似 C++ 的值传递，如整数、字符串。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。

可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响。

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

默认参数

与 C++ 类似。

def printinfo( name, age = 35 ):
   print ("名字: ", name)
   print ("年龄: ", age)
   return

printinfo( age=50, name="runoob" )
printinfo( name="runoob" )

不定长参数

不定长参数以元胞形式导入，存放所有未命名的变量参数。

def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)

printinfo( 70, 60, 50 )

输出是

70
(60, 50)

另一个例子

def printinfo( arg1, *vartuple ):
   print (arg1)
   for var in vartuple:
      print (var)
   return
printinfo( 10 )
printinfo( 70, 60, 50 )

输出是

10
70
60
50

也可以加两个星号，此时不定长参数不用元胞存储，而是用字典存储。

def printinfo( arg1, **vardict ):
   print (arg1)
   print (vardict)
printinfo(1, a=2,b=3)

输出是

1
{'a': 2, 'b': 3}

lambda: 匿名函数

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

将 lambda 封装在 def 中，可以批量定义函数。

def myfunc(n):
  return lambda a : a * n
 
mydoubler = myfunc(2)
mytripler = myfunc(3)
 
print(mydoubler(11))
print(mytripler(11))