Python3学习-基础

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)