Python基础总结

发表于 | 分类于

基础语法

Python3 默认使用UTF-8编码

程序入口

python的程序入口为if __name__ == '__main__':类似于c的main()函数，注意，当其是被作为包倒入时if __name__ == '__main__':中的方法是不会执行的

关键字

1
2
3
4
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 
'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 
'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise',
 'return', 'try', 'while', 'with', 'yield']

注释

#单行 '''多行

代码块

使用缩进代表代码块,不同于java的{},同一个代码块的语句必须包含相同的缩进空格数

字符串

  • \转义符, r\取消转义
  • Python 中的字符串有两种索引方式,从左往右以 0 开始,从右往左以 -1 开始
  • 字符串的截取的语法格式如下：变量[头下标:尾下标]
  • 字符串可以用 + 运算符连接在一起,用 * 运算符重复
  • Python 字符串不能被改变。向一个索引位置赋值,比如word[0] = 'm'会导致错误

print 默认输出是换行的,如果要实现不换行需要在变量末尾加上 end=””,例print( x, end=" " )

input 输入

执行下面的程序就会等待用户输入,注意,input()得到的值都是string,想要将其转换为int,需要int(input('将其转换为int'))

1
2
3
4
5
height = input("请输入你的身高：")
print(height)
# -------------------------------后台显示
请输入你的身高：180
180

基本数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建,变量就是变量,它没有类型

  • Number（数字）
  • String（字符串）
  • List（列表） 元素可被重新赋值
  • Tuple（元组）
  • Sets（集合）
  • Dictionary（字典） 元素可被重新赋值

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

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

对变量赋值x = y是把变量x指向真正的对象，该对象是变量y所指向的。随后对变量y的赋值不影响变量x的指向。

Python可以同时为多个变量赋值,如a, b = 1, 2和a = b = 1

列表

列表(List)和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需元素的新列表。列表写在小括号 [] 里,元素之间用逗号隔开。列表元素可以被重新赋值,列表中的值允许被删除,列表还支持拼接操作,列表有序

  • insert(索引,内容)
  • pop() 删除list末尾的元素，如果有参数i，则删除索引位置为i的元素

元组

元组(Tuple)与列表类似,不同之处在于元组的元素不能修改。元组写在小括号 () 里,元素之间用逗号隔开。元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组,元组不支持拼接操作,元组和列表可以互转,值得注意的是如果定义单个元组,则需要tup = (1,)后面加个,来区分，因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple

集合

集合(set)是一个无序不重复元素的序列,因此，两个set可以做数学意义上的交集、并集等操作可以使用大括号{ }或者set()函数创建集合,注意：创建一个空集合必须用set()而不是{ },因为{ }是用来创建一个空字典。

  • add(key)
  • remove(key)

字典

列表是有序的对象集合,字典(dictionary)是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的,而不是通过偏移存取。它是一个无序的{键(key) : 值(value)}对集合,键(key)必须使用不可变类型所以可以用数字,字符串或元组充当,而用列表就不行（就算是不可变类型内含列表也不行）,创建空字典使用 { },

1
2
3
4
5
6
7
8
person={'name':'keeep','age':18,'sex':'man'}
print(person.keys())
print(person.values())
print(person['name'])
# -------------------------------后台显示
dict_keys(['name', 'age', 'sex'])
dict_values(['yumintao', 18, 'man'])
keeep
1
2
3
4
5
6
# 根据value找key
>>> d1={'a':1,'b':2}
>>> {value:key for key,value in d1.iteritems()}
{1: 'a', 2: 'b'}
>>> {value:key for key,value in d1.iteritems()}[2]
'b'

内置函数

  • int

    用于将一个字符串或数字转换为整型int('110101',2)表示2进制为110101的数转化为10进制（默认）

  • divmod(被除数,除数)

    返回一个包含商和余数的元组,例：divmod(7,2)为7/2=3...1,返回(3,1)

  • all(iterable)

    可迭代参数 iterable 只要有1个为’ ‘、0、false,则返回 False,否则返回true

  • any(iterable)

    可迭代参数 iterable 全部为’ ‘、0、false,则返回 False,否则返回true

  • enumerate()

    将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中

    1
    2
    3
    array = [1,7,3,'s','pi']
    for i, ele in enumerate(array):
       	print(array[i])

  • str(object)

    返回一个对象的string格式

  • eval()

    函数用来执行一个字符串表达式,并返回表达式的值,能使字符串本身的引号去掉,保留字符的原本属性

1
2
3
4
5
6
7
n = '90'
print(type(n))
a = eval(n)
print(type(a))
# -------------------------------后台显示
<class 'str'>
<class 'int'>

身份运算符

  • is 是判断两个标识符是不是引用自一个对象x is y, 类似 id(x) == id(y) id() 函数用于获取对象内存地址
  • is not

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个, == 用于判断引用变量的值是否相等

1
2
3
4
5
6
7
8
9
10
11
12
# =是传递引用,[:]截取字符串中的一部分
>>> a = [1, 2, 3]
>>> b = a
>>> b is a 
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True

条件控制

if语句的关键字为：if – elif – else,python中没有switch – case语句

条件为假：0, false, ' ',None

try-except()

类似于java的try-catch语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
print("=======欢迎进入狗狗年龄对比系统========")
control = 'Y'
while control == 'Y':
    try:
        age = int(input("请输入您家狗的年龄:"))
        if age < 0:
            print("您在逗我？")
        elif age == 1:
            print("相当于人类14岁")

        elif age == 2:
            print("相当于人类22岁")

        else:
            human = 22 + (age - 2) * 5
            print("相当于人类：", human)

    except ValueError:
        print("输入不合法,请输入有效年龄")
    control = input("是否需要再次查询(Y/N):")
###退出提示
input("点击 enter 键退出")

with-as语句

python中用with...as语句来代替复杂的try...finally

1
2
3
4
5
6
7
8
9
10
try:
	file = open('XXXX')
	print(file.read())
finally:
	if file:
		file.close()
---------------------------
# 使用with...as
with open('xxxx') as file:
	print(file.read())

循环语句

  • while ... :
  • for i in range()
1
2
3
4
5
6
7
8
for i in range(5):
    print('你好')
-----------------
你好
你好
你好
你好
你好

break语句用于跳出当前循环体
continue语句被用来告诉Python跳过当前循环块中的剩余语句,然后继续进行下一轮循环,并不跳出当前循环

遍历元素

如果你需要生成数字序列,可以使用内置range(起始数字,结尾数字,步长)函数,注意,range(10,20)是10-19,左闭右开

  • for ... in ... :
  • for i,j in enumerate(...):
1
2
3
4
5
# python中for语句循环不仅可以用在list或tuple上，还可以作用在其他可迭代对象上，比如dict
dd = {'name':'keeep','age':17,'sex':'M'}
# 同时迭代key，value
for  k,v in dd.items():
    print(k,v)
1
2
3
4
5
6
7
# enumerate函数可以把一个可迭代对象变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身
>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

切片

[起始索引:终止索引:步长] 例如：

1
2
3
4
5
6
7
>>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
# 从索引0开始到索引3为止，步长为2
>>> L[0:3:2]
['Michael', 'Tracy']
# 默认从头到尾全部
>>> L[:]
['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']

列表生成式

1
2
3
# 把要生成的元素x * x放到前面，后面跟for循环
>>> [x*x for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

迭代器和生成器

迭代器

迭代器是一个可以记住遍历的位置的对象,从集合的第一个元素开始访问,直到所有的元素被访问完结束。迭代器只能往前不会后退

  • iter() 创建迭代器对象
  • next() 输出迭代器的下一个元素

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

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

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

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

生成器

一边循环一边计算的机制,称为生成器：generator,优点是节省大量的空间

使用了 yield 的函数被称为生成器（generator）,生成器自定义函数规则返回一个迭代器

yield有点像断点,加了yield的函数,每次执行到有yield的时候,会返回yield后面的值,并且函数会暂停,直到下次调用或迭代终止

Python yield 使用浅析

面向函数

1
2
def 函数名（参数列表）:
    函数体

函数名也可以是变量

1
2
3
4
5
6
7
def add(x, y, f):
    return f(x) + f(y)
# 调用函数
add1 = add(5, 7, float)
print(add1)
-----------------------------
12.0

参数

  • 必需参数
  • 是关键字参数，kw接收的是一个dict （**kw）
  • 默认参数
  • 是可变参数，args接收的是一个tuple （*args）
1
2
3
4
5
6
# 注意默认参数必须放在最后面否则报错
# 定义默认参数要牢记一点：默认参数必须指向不变对象
def printinfo( name, age = 35 ):
   print ("名字: ", name)
   print ("年龄: ", age)
   return
1
2
3
4
5
6
7
8
9
10
11
# 不定长参数
'''
仅仅在参数前面加了一个*号。在函数内部，参数vartuple接收到的是一个tuple，因此，函数代码完全不
变。但是，调用该函数时，可以传入任意个参数，包括0个参数
'''
def printinfo( arg1, *vartuple ):
   print ("输出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 关键字参数
# 'kw接收的是一个dict
def person(name, age, **kw):
    if 'city' in kw:
        # 有city参数
        pass
    if 'job' in kw:
        # 有job参数
        pass
    print('name:', name, 'age:', age, 'other:', kw)
#调用函数    
person(22, 'keeep',city = '北京',job = 'web开发')

-----------------------------------------------------------
年龄 22 姓名 keeep other {'city': '北京', 'job': 'web开发'}

高阶函数

  • map(函数，Iterable)
  • reduce()
  • filter(函数，Iterable)
  • sorted(排序参数,排序逻辑, reverse排序顺序)

map()将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。需要用list()函数获得所有结果并返回list

reduce()把一个函数作用在一个序列[X1, X2, X3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算,即reduce(f, [X1, X2, X3, X4]) = f(f(f(X1, X2), X3), X4)

filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素,该函数用于筛选过滤元素，，并把结果作为新的Iterator返回。需要用list()函数获得所有结果并返回list

1
2
3
# 根据字符串小写反向排序
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']

装饰器（类似于AOP，面向切面）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import functools

def log(func):
    @functools.wraps(func)
    # 参数(*args, **kw)表示任意参数
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

@log
def say():
    print("今天天气不错")
# 调用函数
say()
------------------------------------------------
call say():
今天天气不错

偏函数

把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数
functools.partial(函数名,要固定的参数名)

匿名函数

python 使用 lambda 来创建匿名函数，不用写return

表达式lambda [arg1 [,arg2,.....argn]]:expression,例如

1
2
3
4
lambda x: x * x
----------等同于-----------
def f(x):
    return x * x

变量作用域

变量的访问以 L（Local） –> E（Enclosing） –> G（Global） –>B（Built-in）从里到外的规则查找

  • global
  • nonlocal 如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了
1
2
3
4
5
6
7
num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()
1
2
3
4
5
6
7
8
9
10
def test():
    a = 10

    def two():
        nonlocal a # 修改嵌套作用域使用nonlocal关键字
        a = a + 1
        print(a)
    two()

test()

模块

  • __name__属性

每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入

  • dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称

输入和输出

输入

  • 表达式语句
  • print() 函数
  • 使用文件对象的 write()

读和写文件

open(filename, .mode[.buffering])

  • filename：包含了你要访问的文件名称的字符串值。
  • mode：决定了打开文件的模式：只读，写入，追加等。这个参数是非强制的，默认文件访问模式为只读(r)。

  • buffering：缓冲区默认无，参数为1则有缓冲区，负数代表使用默认缓冲区，参数大于1表示缓冲区的大小（单位字节）

    • r读
    • w写
    • a追加
    • b二进制模式（可添加到其他模式中使用） 一般用来处理mp3，图片等格式
    • +读/写模式（可添加到其他模式中使用）

read()/readlines()

仅仅获取到文件是不足以显示的，这个时候我们要用到read()方法，将其一次性读取到内存中去，最后返回str对象

1
2
3
4
with open('/Users/mintaoyu/Desktop/英语默写.txt') as file:
    for f in file.readlines():
    	# 去除首位空格
        print(f.strip())

close()

最后一步调用close()方法，关闭对文件的引用

pickle 模块（序列化/反序列化操作）

  • dump() 将序列化后的对象直接写入文件中
  • dumps() 将任意对象序列化成一个str
  • load()
  • loads()

python的pickle模块实现了基本的数据序列和反序列化。

通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。pickle.dump(obj, file, [,protocol])参数protocol是序列化模式，默认值为0，表示以文本的形式序列化。protocol的值还可以是1或2，表示以二进制的形式序列化。

通过pickle模块的反序列化操作，我们能够从文件中读取上一次程序保存的对象pickle.load(file)

操作文件和目录

对文件和目录的操作经常用到os模块和shutil模块，常用方法

  • os 封装了常用的系统调用
    • 获取当前进程的IDos.getpid()
    • 获得当前Python工作目录 os.getcwd()
    • 返回指定目录下的所有文件和目录名：os.listdir()
    • 删除文件os.remove(filepath)
    • 删除多个空目录os.removedirs()
    • 检验给出的路径是否是一个文件/目录os.path.isfile(filepath)/isdir(filepath)
    • 判断路径是否为绝对路径os.path.isabs()
    • 检验路径是否真的存在os.path.exists()
    • 分离一个路径的目录名和文件名os.path.split()
    • 分离扩展名os.path.splitext()
    • 获取路径名os.path.dirname(filepath)
    • 获取文件名os.path.basename(filepath)
    • 读取和设置环境变量os.getenv()/os.putenv()
    • 指示你正在使用的平台os.name 对于win为’nt’，对于Linux/Unix为’posix’
    • 重命名文件或目录os.rename(srcpath,dstpath)
    • 创建多级目录os.makedirs()
    • 创建单个目录os.mkdir()
    • 获取文件属性os.stat(filepath)
    • 修改文件权限和时间戳os.chmod(filepath,mode)
    • 获取文件大小os.path.getsize(filepath) 返回字节
  • shutil
    • 复制文件夹shutil.copytree(olddir,newdir) 参数必须为目录，且newdir必须原本不存在
    • 复制文件shutil.copyfile(oldfile,newfile)参数必须为文件
    • 将文件复制到新文件或者文件夹shutil.copy(oldfile,new)
    • 移动文件(目录)shutil.move(oldpos,newpos)
    • 删除目录shutil.retree(dir) 无论是否为空都能删除

进程和线程

python中实现多进程有2种方法

  1. 使用os模块的fork()—–支持Unix/Linux
  2. 使用multiprocessing模块—-跨平台
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import os
# 程序入口
if __name__ == '__main__':
    print('current Process (%s) start ...' % (os.getpid()))
    # fork()方法调用1次返回2次，一次为返回子进程ID的父进程，一次为永远是0的子进程
    pid = os.fork()
    if pid < 0:
        print('error in fork')
    elif pid == 0:
        print('I am child process(%s) and my parent process is (%s)' % (os.getpid(), os.getppid()))
    else:
        print('I(%s) created a chlid process (%s).' % (os.getpid(), pid))
---------------------------------------------------------------------------
current Process (2814) start ...
I(2814) created a chlid process (2815).
I am child process(2815) and my parent process is (2814)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

import os
from multiprocessing import Process


# 子进程要执行的代码
def run_proc(name):
    print('Child process %s (%s) Running...' % (name, os.getpid()))


if __name__ == '__main__':
    print('Parent process %s.' % os.getpid())
p = []
for i in range(5):
    p.append(Process(target=run_proc, args=(str(i),)))

    print('Process will start.')

    p[i].start()

for process in p:
    process.join()

print('Process end.')

--------------------------------------------------
Parent process 2883.
Process will start.
Process will start.
Process will start.
Process will start.
Child process 0 (2884) Running...
Process will start.
Child process 1 (2885) Running...
Child process 2 (2886) Running...
Child process 3 (2887) Running...
Child process 4 (2888) Running...
Process end.

multiprocessing模块提供了一个Pool类来代表进程池对象

P = Pool(processes=3)设置容量为3的进程池

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from multiprocessing import Pool
import os, time, random


def run_task(name):
    print('Task %s (pid = %s) is running...' % (name, os.getpid()))
    time.sleep(random.random() * 3)
    print('Task %s end.' % name)


if __name__ == '__main__':
    print('Current process %s.' % os.getpid())
    p = Pool(processes=3)
    for i in range(5):
        p.apply_async(run_task, args=(i,))
    print('Waiting for all subprocesses done...')
    # Pool对象调用join()方法会等待所有子进程执行完毕，调用join()之前必须先调用close()
    p.close()
    p.join()
    print('All subprocesses done.')

面向对象编程

类定义

1
2
3
# 括号中写该类是从哪个类继承下来的，如果是通用的object可以省略(python2.7 不能省)
class Student(object):
    pass

创建实例

直接类名+(定义的参数)即可，不像java那样用new

1
2
3
4
5
6
7
8
9
10
11
12
13
# 继承类为object，省略
class student:
# __init__ 方法的主要作用,就是初始化属性(构造器)
	# self表示创建的实例本身
    def __init__(self,name,age):
        self.name = name
        self.age = age
# 自定义方法
    def printstu(self):
        print('姓名：',self.name,'年龄',self.age)

stu = student('Keeep',22)
stu.printstu()

和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数

赏个🍗吧
0%