python基础全

发表于

最近写微信小程序, 写的头疼. 突然就想温习下python.

1. 数字: 一个整数或者小数

1
2
3
4
5
6
age = 22
price = 2.5
male = True
print(type(age))
print(type(price))
print(type(male))

2. 字符串

1
2
3
4
5
6
7
8
9
name = "dottie"
site_name = '哈哈哈'
html = '''
    helloworld
    hello
'''
print(type(name))
print(site_name)
print(html)

3. 列表:方括号括起来的一组数据

1
2
3
4
5
6
7
8
l = ["你好", 22, '大钟']
print(type(l))
print(l)

for item in l:
    print(item)

print([item for item in l])

4. 元祖: 用圆括号括起来的一组数据

1
2
3
t = (404, "页面未找到", "hh")
print(t)
print(type(t))

5: 字典:用花括号括起来

1
2
3
4
5
6
d = {"name": "dottie", "age": 22}
print(d)
print(type(d))
for k in d.keys():
    print(k)
    print(d[k])

6: 对象

1
2
3
4
5
6
class Person(object):
    pass


p = Person()
print(type(p))

7: 命名规范

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
PI = 3.14


def my_function():
    pass


class CustomManager(object):
    china_name = '中国'

    def get_name(self):
        return "dottie"
        pass

    pass


class MyException(object):
    pass

8: 注释: 文档字符串doc

一般提供给外部使用时, 要标注功能 参数等信息.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Person(object):
    '这是一个Person类'
    pass


print(Person.__doc__)


def say_hello():
    '这是一个打招呼的函数'
    pass


print(say_hello.__doc__)

9: print格式化输出

1
2
3
>    print('%s %d' % (nick_name, age))
>    若只要输出一个格式化参数 就不要再参数列表中加括号
>    当然也有format函数可以调用.
1
2
3
4
5
6
7
8
9
10
11

a = 1;
nick_name = "dottie"
print('%s %d' % (nick_name, a))
print(nick_name, a)

aa = 1.1
print(aa)  # 1.1
print('%d' % aa)  # 1
print('%f' % aa)  # 1.100000
print('%.2f' % aa)  # 1.10

10: 小数对象Decimal, 因为小数之间运算是不精确的(小数+整数是精确的).

1
2
3
4
5
6
7
8
>   from decimal import Decimal
>    分数对象:
>    from fractions import Fraction
>    import math
>    math.pow() floor等等.
>    import random
>    random.random() # 0-1
>    random.choice(range(100)) # 在1-100之前产生一个随机数
1
2
3
4
5
6
7
8
9
aaa = 1.1
bbb = 2.2
print(aaa + bbb)  # 3.3000000000000003

from decimal import Decimal

c = Decimal('1.1')
d = Decimal('2.23')
print(c + d)

11. enumerate可以得到序列(字符串, 列表, 元组)的索引.

1
2
>    调用内置函数enumerate()函数, 该函数参数必须是一个序列. 可以返回一个迭代器 Iterable
    然后Iterable里面有一个__next__()的方法. 返回的是一个元组(index, value)
1
2
3
4
5
6
7
l = ["南财", 'daejong', 22]
for i in l:
    print(i)

for index, value in enumerate(l):
    print(index, value)
    print(type(index), type(value))

12: 内置 max, sort等函数 配合lambda表达式使用 接收的参数也是一个序列

1
2
3
4
5
6
7
8
a = {"id": 1101, "price": 1000}
b = {"id": 1102, "price": 2000}
c = {"id": 1103, "price": 3000}
d = [a, b, c]

print(max(d, key=lambda x: x['id']))  # {'id': 1103, 'price': 3000}

print(sorted(d, key=lambda x: x['price'], reverse=True))

13. 列表推导表达式(返回值是列表), 字典推导表达式(返回值是一个字典)

[表达式 操作 筛选] {表达式 操作 筛选}

1
2
values = ["aa", 'bb', 'cc']
print({k: values[k] for k in range(3)})  # {0: 'aa', 1: 'bb', 2: 'cc'}

14: 迭代器(用的不多), 直接使用for while循坏即可迭代

iter(序列) 返回一个迭代器
next(迭代器) 返回具体的值

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
l = ["aa", 22, 'cc']
it = iter(l)
print(type(it))  # 列表迭代器<class 'list_iterator'>
# print(next(it)) ## aa
# print(next(it)) ## 22
# 多次调用会触发异常

t = (200, "请求成功!")
it1 = iter(t)
print(type(it1))  # 元组迭代器 <class 'tuple_iterator'>

# 可以捕获迭代器异常
while True:
    try:
        print(next(it))
    except StopIteration as ex:
        print(ex)
        print("到达最后一个元素了...")
        break

d = {1: "hhh", 2: "222"}
it2 = iter(d)
print(type(it2)) # <class 'dict_keyiterator'>
print(next(it2)) # 1
for k in it2:
    print(k, d[k])

15: 生成器(用户很多): 是一个(里面使用 yield 关键字) 函数

1
2
3
4
5
6
>    yield 让一个函数执行过程中停止下来, 下次执行时, 继续从上次停下来的位置执行.
    生成器是一种推导逻辑, 调用生成器会返回一个迭代器.
>    生成器创建方法:
>    1. 改列表推导式[] 为 ()
>    2. 使用带有yield关键字的函数
    作用: 可以得到运算过程中的每次结果.(存储在生成器中)
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
l = [2 * x for x in range(3)]
print(l) # [0, 2, 4]

g = (2 * x for x in range(3)) # g是一个生成器(调用()表达式创建一个生成器)
print(type(g)) #<class 'generator'>
print(next(g)) # 0
print(next(g)) # 2
print(next(g)) # 4

def my_function():
    print("first step")
    yield
    print("second step")
    yield
    print("third step")
    yield

g1 = my_function() #返回一个迭代器
print(type(g1)) #<class 'generator'>
next(g1) # first step
next(g1) # second step
next(g1) # third step
# next(g1) # StopIteration异常


def hello_world():
    a = 1
    for i in range(2):
        a += 10
        yield a

g = hello_world()
print(next(g)) #11
print(next(g)) #21

16: 函数的定义和调用 函数的高级使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def say_hello(name):
    print("hello", name)

say_hello("dottie")

from time import sleep
def loop():
    a = 1
    while True:
        print(a)
        sleep(1)
        a = a + 1
        if a == 4:
            return

# loop()

17: 函数参数

  1. 必要参数
  2. 关键字参数
  3. 默认参数
  4. 不定长参数
  5. lambda表达式, 匿名函数
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
# 1. 必要参数
def fun(name):
    pass
fun("hello") # 必须要传参数.

# 2. 关键字参数
def fun1(name, age):
    print(name, age)

fun1(age = 22, name = "dottie")

# 3. 默认参数
def fun2(age, name="dottie"):
    print(age, name)

fun2(22)

# 4. 不定长参数
def fun3(*args):
    print(type(args)) # <class 'tuple'>
    for i in args:
        print(i)

fun3(1, 2, 3, 4)

# 5. lambda表达式, 匿名函数
fun4 = lambda a, b : a + b
print(fun4(1, 100))

18: 变量作用域

  1. Local 局部作用域
    定义地方: 函数内部, 或者函数的参数
  2. Enclosing 闭包函数外的函数中
  3. Global 全局作用域,
    定义地方: 函数外部

  4. Build-in 内建作用域
    如 math.pi pi就是内建变量

    查找过程: E->L->G->B

*还有局部不可修改全局, 但是>>**
如果非要修改: 要在局部 用关键字 global global_var 来修饰下 才可以修改

*还有闭包中不可以修改自由变量, 但是>>**
如果非要修改: 要在闭包中 用关键字 nonlocal local_var 来修饰下 才可修改

1
2
3
4
5
6
7
8
9
10
# 闭包
def outer():
    number = 100
    def inner():
        number = 101
        print(number)
    inner()
    print(number)

outer()

19: **注意: 跟其他语言完全不同.**

除了 def class lambda定义的代码块, python代码代码块不会引入新的作用域.

1
2
3
4
5
6
7
def hello():
    if True:
        a = 1123123
    print(a) # 这里还是访问到a的

print(a) # 除了def定义的代码块就访问不到变量a的值了. 除了作用域了.
hello() # 1123123

20: 闭包(函数式编程中重要概念) **重在理解概念

1
2
3
>    在一个函数内部, 对外部作用域(但不是全局作用域)的变量进行引用, 那么内部函数就成为闭包(closure)
>    定义在外部函数中而被内部函数使用的变量称作是 自由变量.
>    闭包是引用了自由变量的函数, 而这个被引用了的自由变量将和这个闭包一同存在, 即使离开了创建他的环境(外部函数)
1
2
3
4
5
6
7
8
def line_conf():
    b = 15
    def line(x):
        return 2 * x + b
    return line

my_line = line_conf()
print(my_line(5)) # 25

21: python的模块和包 from fractions import Fraction

  1. 模块的概念
    就是一个.py结尾的文件, 这里面有一些类和函数的声明, 不同模块之间可以使用 import 导入需要的模块
    方便我们组织代码.
  2. 模块的命名空间,
    1. 通过模块的名字来区分
      如果命令行中要使用其他模块. 需要将模块的路径加到 sys.path(是一个列表)中,
      import sys
      使用sys.path.append(r’/usr/local/hello.py’) 这里的r是表示后面原生字符串, 不要转换.
      也可以使用sys.modules 查看系统帮助我们已经导入的模块(这也是我们一开始不用导入模块就可以写代码的原因)
  3. 导入方式
    1. import mod.py # 导入mod整个模块
    2. from mod import Avg, HelloClass # 导入mod模块中Avg函数和HelloClass类
    3. from mod import Sum as m # 导入mod模块中Sum函数或者类 并且命名为m

  4. 当导入模块时, 模块会被执行, 模块可以被导入多次, 但是只会执行一次.

  5. 包就是一个文件夹, 包里面有一个init.py 导入该包时, 该模块会被执行.
    包里面放的就是模块
    如: com 中有—util.py 里面有一个format_time()函,,有init.py有online.py
    如果我们要在其他模块使用format_time函数
    import sys
    sys.path.append(r’/usr/local/xxxx/xxxx/com的上一级’)

    1. import com.util
      com.util.format_time()
    2. from com import util
      util.format_time()
    3. from com.util import format_time
      format_time()
    4. from com.util import * # 导入com包下面所有的模块
      format_time()
1
2
3
4
5
6
7
8
9
10
11
12
13
# 定义一个模块mod.py
# def say_hello():
#     print("hello")
#
# def avg(l):
#     return sum(l)/len(l)

# 在other.py模块中引入mod.py
# import mod.py
#
# mod.say_hello()
# r = mod.avg([1, 3, 5])
# print(r)

22: 异常捕获和处理 以及 常见异常 Exception

try:
pass
except StopIteration as e:
pass
except ValueError as e:
pass
finally:
pass

  1. 主动抛出异常 raise ValueError
  2. 设置断言 assert(100==101) # 抛出AssertionError异常, 一般用于调试程序
  3. 自定义异常
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

age = input("请输出年龄: ")
try:
    age_temp = int(age)
    print(age_temp)
except ValueError as ex:
    print("发生错误", ex)

# 自定义异常 继承自Exception, 使用时要通过raise抛出异常
class AgeException(Exception):
    def __init__(self, info):
        Exception.__init__(self)
        self.info = info

    def __str__(self):
        return "异常为 " + self.info

# 使用自定义异常
age = -1
try:
    if age < 0:
        raise AgeException("年龄不能小于0...")
except AgeException as ageEx:
    print(ageEx)

1. python面向对象

  1. 构造方法 def init(self): 不支持构造函数的重载, 只能有一个构造函数.
  2. class中的所有方法第一个参数必须是self,
  3. self指的就是当前对象, self也可以用this代替
  4. 类没有静态变量, 但是可以有静态方法@staticmethod标注在方法上面
    可以通过类的实例化后的对象调用, 也可以直接通过类名调用,
    静态方法中不可以访问外部的变量
  5. 类属性: 定义在类中方法外的. 可以通过类名或者实例对象来访问
  6. 类的实例属性: 在init方法中初始化的属性, 必须实例对象才可以访问.
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
39
40
41
42
43
44
45
46
47
48
49
class Person(object):
    '这是一个Person类'

    # 默认就是无参数的构造函数
    def __init__(self):
        print("执行构造方法")
    # 只能有一个构造函数
    # 注意python中不支持重载, 在构造函数中添加自己的参数, 并且进行初始化
    def __init__(self, name):
        self.name = name

    def display(self):
        print("name = %s" % self.name)

    def ride(self, b):
        b.run()


class Bycyle(object):
    def run(self):
        print("run...")


# baoma = Bycyle()
# xiaoming = Person()
# xiaoming.ride(baoma)

xiaohong = Person("xiaohong")
xiaohong.display()

class Computer(object):
    def __init__(self, name):
        print(id(self))
        self.name = name
    def __str__(self):
        return "computer name is " + self.name

    @staticmethod
    def staticmethod():
        print("我是静态方法")

appleComputer = Computer("apple")
print(id(appleComputer))
print(appleComputer)

appleComputer.staticmethod()
appleComputer.staticmethod()

print(appleComputer.name)

1. python内存管理: 自动完成, 通过垃圾回收器管理内存, 原理是引用计数.

  1. 析构方法 def del(): 当对象从内存释放时, 调用该方法
  2. 继承方法和属性, 也可以多重继承 class Worker(Father, SuperFather)
    super()即为得到父类对象. 可以通过这个调用父类的方法和属性.
  3. 方法覆盖, 子类中使用和父类同名的方法, 即为覆盖父类的方法
  4. 抽象类和接口
  5. 类和类实例的内建函数
    issubclass(Worker, Father)
    isinstance(a_worker, Worker)
    hasattr(p, ‘name’)
    getattr(p, ‘name’)
    setattr(p, ‘name’, ‘daejong’)
    dir(a_worker) 查看对象所有信息
    super() 引用父类
    vars(a_worker) {‘name’: ‘worker’, ‘age’: 22}
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
39
40
41
42
43
44
45
46
47
class Phone(object):
    def __init__(self, name):
        self.name = name

    def __del__(self):
        print("Phone 对象从内存释放了....")

iphone = Phone("iPhone")
print(iphone.name)
print(id(iphone))
iphone2 = iphone
print(id(iphone2))

class Father(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print("eat...")

    def sleep(self):
        print("sleep...")

class Worker(Father):
    def __init__(self):
        super().__init__("worker", 22)

    def work(self):
        print("work....")

a_worker = Worker()
a_worker.work()
a_worker.eat()
a_worker.sleep()
print(a_worker.name)
print(a_worker.age)

print(issubclass(Worker, Father)) # True
print(issubclass(Worker, object)) # True

print(isinstance(a_worker, Worker)) # True
print(isinstance(a_worker, object)) # True

print(dir(a_worker))

print(vars(a_worker))

import pickle(C语言写的, 慢)

推荐用cPickle
对象的序列化和反序列化

  1. 序列化: 将对象持久保存成文件格式 (dump)
  2. 反序列化: 将文件转换成对象 load
  1. 访问控制: python没有真正的访问控制, 只是通过变量名来约定
    命名_foo 表示protected
    命名__foo 表示private
    这只是一种约定而已.