1.直接运行.py文件
在Windows上是不行的，但是在Mac和Linux上是可以的，方法是在.py文件的第一行加上一个特殊的注释：
#!/usr/bin/env python3
print('hello world')
然后，通过命令给hello.py以执行权限：
$chmod a+x hello.py
2.输入
name=input()
input()可以显示一个字符串来提示用户：
name=input('please enter your name')
input()返回的数据类型是str，使用int()将其转换成整数。
3.转义符
如果'是一个字符，那么可以用""括起来。
如果字符串中既包含'又包含"，可以用转义字符\来标识。比如：
'I \'m \"OK\"'
为了简化，Python允许用r''表示''内部的字符串默认不转义。
'''...'''表示多行内容
4.//表示地板除，只取结果的整数部分。
5.现在计算机通用的字符编码工作方式：在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换成utf-8编码。ord()函数获取字符的整数表示，chr()函数将编码转成对应的字符。
如果知道字符的整数编码，还可以用十六进制这么写str:
'\u4e2d\u6587'
'中文'
两种写法是完全等价的。
由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络中传输或者保存到磁盘上，就需要把str变成以字节为单位的bytes。Python对bytes类型的数据用带b前缀的单引号或双引号表示：
x=b'ABC'
要注意区分'ABC'和b'ABC'，前者是str，后者虽然内容显示得和前者一样，但bytes的每个字符都只占用一个字节。
以Unicode表示的str通过encode()方法可以编码为指定的bytes，例如：
'ABC'.encode('ascii')
'中文'.encode('utf-8')
'中文'.encode('ascii')
b('ABC')
b('\xe4\xb8\xad\xe6\x96\x87')
报错
纯英文的str可以用ASCII编码为bytes，内容是一样的，含有中文的str可以用UTF-8编码为bytes。含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错。
反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法：
b'ABC'.decode('ascii')
'ABC'
b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'
由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：
#!/usr/bin/env python3
#-*- coding:utf-8 -*-
6.格式化
‘Hell0,%s' % 'world'
'Hello,%s, you have $%d' % ('Michael',1000)
%d %f %s %x
格式化整数和浮点数还可以指定是否补0和整数与小数的位数：
'%2d-%02d'%(3,1)
' 3-01'
'%.2f'%3.1415926
'3.14'
%%转义，表示一个%
7.list删除指定位置的元素，使用pop(i)方法：
classmates.pop(1)
i是索引位置。
要把某个元素替换成别的元素，可以直接赋值给对应的索引位置:
classmate[1]='Sarah'
list中的数据类型可以不同，list中的元素也可以是另一个list。此时，含有list的list可以看成是一个二维数组。
8.tuple
另一种有序列表叫元组：tuple。tuple和list非常相似，但是tuple一旦初始化就不能修改。
classmates=('Michael','Bob','Tracy')
t=(1)
上面的代码定义的不是tuple，而是一个数。为了消除歧义：
t=(1,)
当tuple中含有list的时候，list中的元素时可以改变的，但是tuple中list的指向是不可以变化的。
9.if x 如果x是非零数值、非空字符串、非空list，就可以判断为True。
10.dict根据key来计算value的存储位置，哈希算法，所以key的对象不能变，list不可以作为key。
11.set是key的集合，不存储value。add() remove()。可以看成数学意义上的无序和无重复元素的集合，可以做数学意义上的交集和并集操作：
s1=set([1,2,3])
s2=set([2,3,4])
s1&s2
s1|s2
12.如果想定义一个什么事也不做的空函数，可以使用pass语句。
def nop():
pass
pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。pass还可以用在其他的语句里：
if age>=18:
pass
13.对参数类型进行检查：
if not isinstance(x,(int,float)):
raise TypeError('bad operand type')
14.函数的返回值实际上是一个tuple，多个变量可以同时接收一个tuple，按位置赋给对应的值。
15.默认参数必须指向不可变对象，L=[]，为list，是一个可变的对象，每次调用的时候会记忆之前的list。
16.定义可变参数。
def calc(*numbers):
sum=0
for n in numbers:
sum+=n*n
return sum
如果已经有一个list或者tuple，要调用一个可变参数:
nums=[1,2,3]
calc(*nums)
表示把nums这个list的所有元素作为可变参数传进去。
17.关键字参数
关键字参数有扩展函数的功能。
extra={'city':'Beijing','job':'Engineer'}
person('Jack',24,**extra)
**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
18.命名关键字参数
对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过kw检查。
仍以person()函数为例，我们希望检查是否有city和job参数：
def person(name, age, **kw):
if 'city' in kw:
# 有city参数
pass
if 'job' in kw:
# 有job参数
pass
print('name:', name, 'age:', age, 'other:', kw)
如果要限制关键字参数的名字，使用命名关键字参数：
def person(name, age, *, city, job):
print(name, age, city, job)
和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。
调用方式如下：
person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer
如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
def person(name, age, *args, city, job):
print(name, age, args, city, job)
命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错。
19.参数组合
参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数、关键字参数
def f1(a,b,c=0,*args,**kw):
print ('a=',a,'b=',b,'c=',c,'args=',args,'kw=',kw)
def f2(a,b,c=0,*,d,**kw):
print ('a=',a,'b=',b,'c=',c,'d=',d,'kw=',kw)
在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去：
f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
f1(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}
通过一个tuple和dict，也可以调用上述函数：
args = (1, 2, 3, 4)
kw = {'d': 99, 'x': '#'}
f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
args = (1, 2, 3)
kw = {'d': 88, 'x': '#'}
f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}
对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。
20.解决递归调用栈溢出的方法是通过尾递归优化。尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。
def fact(n):
return fact_iter(n, 1)
def fact_iter(num, product):
if num == 1:
return product
return fact_iter(num - 1, num * product)
