python基础知识总结（零基础必看）

命令行模式和Python交互模式

命令模式：它的提示符类似C:\>

交互模式：在命令行模式下敲命令python它的提示符是>>>输入exit() 返回命令模式

在交互模式的提示符>>>下，直接输入代码，按回车，就可以立刻得到代码执行结果

用print()函数，把打印的文字用单引号或者双引号括起来，但不能混用单引号和双引号

执行一个.py文件只能在命令行模式执行

交互模式的代码是输入一行，执行一行，而命令行模式下直接运行.py文件是一次性执行该文件内的所有代码

输入和输出

用print()在括号中加上字符串，就可以向屏幕上输出指定的文字

print()函数也可以接受多个字符串，用逗号“,”隔开，就可以连成一串输出，遇到逗号“,”会输出一个空格

input()，可以让用户输入字符串，并存放到一个变量里

input()可以让你显示一个字符串来提示用户，例如name=input(“please input your name: \n“)

以#开头的语句是注释，注释是给人看的，可以是任意内容，解释器会忽略掉注释。

当语句以冒号:结尾时，缩进的语句视为代码块

Python程序是大小写敏感的，如果写错了大小写，程序会报错

数据类型

如果'本身也是一个字符，那就可以用""括起来，比如"I'm OK"

如果字符串内部既包含'又包含"怎么办？可以用转义字符\来标识

‘I\’m\”ok”\!’表示I’m “ok”!

转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\

r''表示''内部的字符串默认不转义

Python允许用'''...'''的格式表示多行内容

在Python中，可以直接用True、False表示布尔值（请注意大小写）

布尔值可以用and、or和not运算, 布尔值经常用在条件判断中

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值

变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型

在Python中，通常用全部大写的变量名表示常量

/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数

还有一种除法是//，称为地板除，两个整数的除法仍然是整数//除法只取结果的整数部分，所以Python还提供一个余数运算%

单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符

在Python中，采用的格式化方式和C语言是一致的，用%实现

"Hi，%s,you have $%d."%("wangpeng",100000)

另一种格式化字符串的方法是使用字符串的format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}，:后面的.2f指定了格式化参数（即保留两位小数）

数据类型：列表list是一种有序的集合，可以随时添加和删除其中的元素

classmates=['王明','李明','赵明','张明']

索引：classmates[0]，是从0开始

用len()函数可以获得list元素的个数

如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引

classmates[-1]  == classmates[len(classmates)-1]

往list追加元素，默认到末尾

classmates.append('小铭')

插入元素到指定位置

classmates.insert(1,'小红')

删除list末尾元素，用pop()默认删除最后一个

classmates.pop()

删除list指定元素，用pop(i)删除第i个,第一个序号为0

classmates.pop(1)

替换列表中的元素，用赋值的方式

classmates[0]=‘王明1’

列表中的元素数据类型可以不同

列表里面可以添加其他列表，但是只能算作一个“大“元素

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改

获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素

List使用的是[ ]初始化，而tuple使用的是（）初始化，两者都是有序列表，前者可以增加删除修改元素，后者一旦初始化就不能改变元素的值，查找方式相同

如果要定义一个空的tuple，可以写成()但是，要定义一个只有1个元素的tuple，可以写成t=(1,)加“,”是消除歧义

条件判断：

if <条件判断1>:

    <执行1>

elif <条件判断2>:

    <执行2>

elif <条件判断3>:

    <执行3>

else:

<执行4>

input()返回的数据类型是str，str不能直接和整数比较，必须先把str转换成整数。Python提供了int()函数来完成

birth=int(birth)

Python的循环有两种，一种是for...in循环，依次把list或tuple中的每个元素迭代出来

所以for x in 列表名循环就是把每个元素代入变量x，然后执行缩进块的语句

range()函数，可以生成一个整数序列

for x in 列表名:

循环体

第二种循环是while循环，只要条件满足，就不断循环，条件不满足时退出循环

While 条件:

循环体

在循环中，break语句可以提前退出循环

continue的作用是提前结束本轮循环，并直接开始下一轮循环

死循环解决方法：可以用Ctrl+C退出程序

dict的使用（dict全称dictionary）使用键-值（key-value）存储，具有极快的查找速度

字典名称={‘键‘：值, ‘键‘：值, ‘键‘：值, ‘键‘：值}

查找方法：字典名称[‘键‘]

把数据放入dict的方法，除了初始化时指定外，还可以通过key放入

字典名称[‘键‘]=值，之前的值会被后面的值所覆盖掉

判断键是否存在，方式一用 in的方式，会返回布尔值

使用方式：键 in 字典名称

二是通过dict提供的get()方法，如果key不存在，可以返回None（交互式环境不显示），或者自己指定的value

字典名.get(‘键’,’不存在-1’)

dict内部存放的顺序和key放入的顺序是没有关系的，dict的key（键）必须是不可变对象

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作 用& 和 |做运算

添加key用set名.add(key) 

删除key用set名.remove(key)

set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象

函数

绝对值的函数abs（）

函数max()可以接收任意多个参数，并返回最大值

数据类型转换函数，比如int()函数，float()函数，str()函数，bool()函数

函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”

调用函数方式：函数名(参数)

传入的参数务必保证个数正确，数据类型正确，否则报错

定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

def my_abs(x):

    if x >= 0:

        return x

    else:

        return -x

在Python交互环境中定义函数时，注意Python会出现...的提示。函数定义结束后需要按两次回车重新回到>>>提示符下

空函数 def None():

         pass

pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。缺少了pass，代码运行就会有语法错误。

Python的函数返回多值其实就是返回一个tuple，但写起来更方便。

定义函数时，需要确定函数名和参数个数；如果有必要，可以先对参数的数据类型做检查；函数体内部可以用return随时返回函数结果；函数执行完毕也没有return语句时，自动return None。函数可以同时返回多个值，但其实就是一个tuple。

默认函数参数，放在必选参数后，默认参数必须指向不变对象！

可变参数的实现是通过在调用函数时，传入参数为一个list或者tuple形式。

*nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见

关键字参数，**key, 以传入任意个数的关键字参数

函数原型：

def person(name, age, **kw):

    print('name:', name, 'age:', age, 'other:', kw)

extra = {'city': 'Beijing', 'job': 'Engineer'}

person('Jack', 24, **extra)

name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

person('Bob', 35, city='Beijing')

name: Bob age: 35 other: {'city': 'Beijing'}

这些关键字参数在函数内部自动组装为一个dict

函数参数部分需要加深理解

如果一个函数在内部调用自身本身，这个函数就是递归函数。

def fact(n):

if n==1:

return 1

else:

return n*fact(n-1)

递归调用的次数过多，会导致栈溢出

Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。

切片操作符 例如：>>>L[0:3]表示取L这个list中，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2

倒数第一个元素的索引是-1

>>> L[:10]表示取前十个数0~9如果第一个索引是0，可以省略

>>>L[:10:2]表示前十个数，每两个取一个

甚至什么都不写，只写[:]就可以原样复制一个list：

tuple也可以用切片操作，只是操作的结果仍是tuple

字符串'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串

迭代：

如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代。只要是可迭代对象，无论有无下标，都可以迭代，比如dict就可以迭代。

默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()。

d = {'a': 1, 'b': 6, 'c': 8}

for key in d:

    print(key)      //默认情况下迭代键

for value in d.values():

print(value)    //迭代值用for value in d.values()

for k,v in d.items():

       print(k,v)  //同时迭代键和值

字符串也可迭代

for x in 'ABC':

   print(x)

判断一个对象是可迭代对象,方法是通过collections.abc模块的Iterable类型判断。

>>>from collections.abc import Iterable

>>>isinstance('abc', Iterable)  //实例判断”abc”是否可迭代

Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身。

上面的for循环里，同时引用了两个变量，在Python里是很常见的。

列表生成式是Python内置的非常简单却强大的可以用来创建list的生成式

例如创建list[1,2,3,4,5,6,7,8,9,10]

list(range(1, 11))

要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做？

方式一：循环

>>>L=[]

>>>for x in list(range(1,11)):

       L.append(x*x)

>>>L

方式二：

列表生成式则可以用一行语句代替循环生成上面的list

>>> [x * x for x in range(1, 11)]

写列表生成式时，把要生成的元素x * x放到前面，后面跟for循环，就可以把list创建出来.

生成偶数列表

[x*x for x in range(1,10) if x%2==0]

使用两层循环，可以生成全排列：

[m+n for n in 'ABC' for n in 'xyz']

运用列表生成式，可以写出非常简洁的代码。

>>>Import os //导入os模块

>>>[x for x in os.listdir(‘.‘)]  // os.listdir()可以列车文件和目录

for循环其实可以同时使用两个甚至多个变量，比如dict的items()可以同时迭代key和value。

列表生成式也可以用两个变量来生成list

把一个list中所有的字符串变成小写

>>>L = ['Hello', 'World', 'IBM', 'Apple']

>>>[s.lower() for s in L]

列表生成式[]中，for前面的if ... else是表达式，而for后面的if是过滤条件，不能带else

使用内建的isinstance函数可以判断一个变量是不是字符串

>>>X=123

>>>isinstance(x, str)

在Python中，这种一边循环一边计算的机制，称为生成器：generator

生成器：不必创建完整的list，从而节省大量的空间。

创建方式

把列表生成式的[ ]改为( )便是一个生成器

>>>[ x for x in range(1,11)]  //列表生成式

>>>(x for x in range(1,11))   //生成器

通过next()函数获得生成器的下一个返回值每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误.

上面这种不断调用next(g)实在是太慢了，正确的方法是使用for循环，因为generator也是可迭代对象。迭代无需关心StopIteration的错误.

for x in g:

print(x)

而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。

可以直接作用于for循环的对象统称为可迭代对象：Iterable

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator

生成器都是Iterator对象，但list、dict、str虽然是Iterable（可迭代对象），却不是Iterator（迭代器）。

凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的

函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！

函数本身也可以赋值给变量，即：变量可以指向函数。

函数名其实就是指向函数的变量！对于abs()这个函数，完全可以把函数名abs看成变量，它指向一个可以计算绝对值的函数。

把abs指向10后，就无法通过abs(-10)调用该函数了！因为abs这个变量已经不指向求绝对值函数而是指向一个整数10！

既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

def add(x, y, f):

    return f(x) + f(y)

调用add(-5, 6, abs)

(x) + f(y) ==> abs(-5) + abs(6) ==> 11

编写高阶函数，就是让函数的参数能够接收别的函数

Python内建了map()和reduce()函数。

map()函数接收两个参数，一个是函数，一个是Iterable（可迭代对象）

map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator（（可迭代对象））返回。

>>> def f(x):

     return x * x

>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> list(r)

[1, 4, 9, 16, 25, 36, 49, 64, 81]

reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数

求累加运算

reduce(add, [1, 2, 3, 4]) = add(add(add(1,2),3),4)

filter()函数用于过滤序列。

filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

在一个列表中去掉偶数

用filter()这个高阶函数，关键在于正确实现一个“筛选”函数。

filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。

sorted()函数就可以对list进行排序

sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序。

>>>sorted([36, 5, -12, 9, -21], key=abs)

key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序

默认情况下，对字符串排序，是按照ASCII的大小比较的，由于'Z' < 'a'，结果，大写字母Z会排在小写字母a的前面

忽略大小写来比较两个字符串，实际上就是先把字符串都变成大写（或者都变成小写），再比较。通过str.lower（）函数。

返回函数：函数作为结果值返回。

匿名函数lambda x: x * x 冒号前面的x表示函数参数。匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

现在，假设我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2

import functools

>>> int2 = functools.partial(int, base=2)

>>> int2('1000000')

64

偏函数：把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。

在Python中，一个.py文件就称之为一个模块（Module）

 自己创建模块时要注意命名，不能和Python自带的模块名称冲突。例如，系统自带了sys模块，自己的模块就不可命名为sys.py，否则将无法导入系统自带的sys模块

模块是一组Python代码的集合，可以使用其他模块，也可以被其他模块使用。创建自己的模块时，要注意：

模块名要遵循Python变量命名规范，不要使用中文、特殊字符；

模块名不要和系统模块名冲突，最好先查看系统是否已存在该模块，检查方法是在Python交互环境执行import abc，若成功则说明系统存在此模块。

导入模块

Import 模块名

，必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。