python基础

2020-07-01  本文已影响0人  文知道

特点

历史

数据类型

  1. 整型：int 8
  2. 浮点型：float 8.5
  3. 字符：str "6"
  4. 布尔型：bool true false
数据类型操作

序列

定义

它的成员都是有序排列，并且可以通过下标偏移量访问它的成员。

范围
  1. 字符串 "abc"
  2. 列表 [4,6,7] 成员可以变更
  3. 元组 ("234", "hi") 成员不可变更
序列基本操作
# 下标从0开始，包含开头，不包含结尾
# 格式：序列[开始下标:结束下标]

a = [4,6,7]
a[1]  # 结果为：6
a[1:2]  # 结果为：[6]
列表基本操作

字典{}

集合{}

条件语句if

if 条件:
  执行语句
elif 条件:
  执行语句
else:
  执行语句

循环语句while

while 条件:
  执行语句

循环语句for

for 迭代变量 in 可迭代对象:
  执行语句

映射类型：字典{}

文件操作

错误≠异常

迭代器

生成器

a,b=b,a+b 和 a=b b=a+b 的区别

a,b=0,1
a, b = b, a+b
# 这种赋值，先计算等值 右边 就是 b=1 a+b=1
# 再赋值给a和b，那么 a=1, b=1
#然后就是依次这样

a = b
# 此时 b=1, 那么a=1
b = a+b
# 那么 b=2

匿名函数lambda

一个语法
 lambda argument_list: expression
三个特性
  1. lambda函数是匿名的：所谓匿名函数，通俗地说就是没有名字的函数。lambda函数没有名字。
  2. lambda函数有输入和输出：输入是传入到参数列表argument_list的值，输出是根据表达式expression计算得到的值。
  3. lambda函数一般功能简单：单行expression决定了lambda函数不可能完成复杂的逻辑，只能完成非常简单的功能。由于其实现的功能一目了然，甚至不需要专门的名字来说明。
四个用法
  1. 将lambda函数赋值给一个变量，通过这个变量间接调用该lambda函数。
  2. 将lambda函数赋值给其他函数，从而将其他函数用该lambda函数替换。
  3. 将lambda函数作为其他函数的返回值，返回给调用者。
  4. 将lambda函数作为参数传递给其他函数。
一个争议

内建函数

filter()
filter(function, iterable)
# function -- 判断函数。
# iterable -- 可迭代对象。
# 返回一个迭代器对象

def is_odd(n):
    return n % 2 == 1
 
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)
# 结果为：[1, 3, 5, 7, 9]
map()
map(function, iterable, ...)
# function -- 函数
# iterable -- 一个或多个序列
# Python 2.x 返回列表。
# Python 3.x 返回迭代器。

# 使用 lambda 匿名函数
map(lambda x: x ** 2, [1, 2, 3, 4, 5])  
# [1, 4, 9, 16, 25]
# 提供了两个列表，对相同位置的列表数据进行相加
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
# [3, 7, 11, 15, 19]
reduce()
reduce(function, iterable[, initializer])
# function -- 函数，有两个参数
# iterable -- 可迭代对象
# initializer -- 可选，初始参数

from functools import reduce
def add(x,y):
    return x + y
print (reduce(add, range(1, 3)), 4)
# 10
zip()
zip([iterable, ...])
# iterabl -- 一个或多个迭代器;
# python3返回的是对象，python2返回的是列表

z = zip([1,2,3],[4,5,6])
print(list(z))
# [(1, 4), (2, 5), (3, 6)]

闭包

  1. 必须要有一个内嵌函数
  2. 内嵌函数中要对自由变量的引用
  3. 外部函数必须返回内嵌函数
# a * x + b = y
def line(a,b):
    def arg_x(x):
        return a * x + b
    return arg_x

a_line = line(2,5)
print(a_line(1))
# 7

装饰器

import time

def timer(func):
    def wrapper():
        start_time  = time.time()
        func()
        stop_time  = time.time()
        print(stop_time-start_time)
    return wrapper
# 装饰器
@timer 
def i_can_sleep():
    time.sleep(2)

i_can_sleep()

函数的基本概念

上下文管理器

class Resource():
    def __enter__(self):
        print('===connect to resource===')
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('===close resource connection===')
        
    def operate(self):
        print('===in operation===')
        
with Resource() as res:
    res.operate()

输出：
===connect to resource===
===in operation===
===close resource connection===

面向对象

继承
class Test:
    def prt(self):
        print(1)


class Test2:
    def prt(self):
        print(2)


class Test3(Test, Test2):
    def __init__(self):
        print(3)


t = Test3()
t.prt()

# 3  1

多线程

import threading
import time
from threading import current_thread


def my_thread(arg1, arg2):
    print(current_thread().getName(), "start")
    print("%s %s" % (arg1, arg2))
    time.sleep(2)
    print(current_thread().getName(), "stop")


for i in range(1,6,1):
    t1 = threading.Thread(target=my_thread, args=(i, i+1))
    t1.start()


print(current_thread().getName(), "end")

Thread-1 start
# 1 2
# Thread-2 start
# 2 3
# Thread-3 start
# 3 4
# Thread-4 start
# 4 5
# Thread-5 start
# MainThread end
# 5 6
# Thread-4 stop
# Thread-3 stop
# Thread-1 stop
# Thread-2 stop
# Thread-5 stop

正则表达式

Python是如何进行内存管理的

  1. 对象的引用计数机制

  1. 垃圾回收
    当一个对象的引用计数归零时，它将被垃圾收集机制处理掉。

  2. 内存池机制

Numpy

上一篇下一篇

猜你喜欢

热点阅读