在程序中,有时我们需要对2个数据进行求和,那么该怎样做呢?
大家类比一下现实生活中,比如去超市买东西,往往咱们需要一个菜篮子,用来进行存储物品,等到所有的物品都购买完成后,在收银台进行结账即可
如果在程序中,需要把2个数据,或者多个数据进行求和的话,那么就需要把这些数据先存储起来,然后把它们累加起来即可
在Python中,存储一个数据,需要一个叫做变量的东西,如下示例:
num1 = 100 #num1就是一个变量,就好一个小菜篮子 num2 = 87 #num2也是一个变量 result = num1 + num2 #把num1和num2这两个"菜篮子"中的数据进行累加,然后放到 result变量
· 说明:
· 所谓变量,可以理解为菜篮子,如果需要存储多个数据,最简单的方式是有多个变量,当然了也可以使用一个
· 程序就是用来处理数据的,而变量就是用来存储数据的
不可变数据:数字,字符串,元组
可变数据:列表,字典,集合
在python中,只要定义了一个变量,而且它有数据,那么它的类型就已经确定了,不需要咱们开发者主动的去说明它的类型,系统会自动辨别
可以使用type(变量的名字),来查看变量的类型
append用于在列表末尾追加新的对象
a = [1,2,3] a.append(4) #the result :[1,2,3,4]
count方法统计某个元素在列表中出现的次数
a=['aa','bb','cc','aa'] print(a.count('aa')) the result : 3
extend方法可以在列表的末尾一次性追加另一个序列中的多个值
a = [1,2,3] b = [4,5,6] a.extend(b) #the result :[1, 2, 3, 4, 5, 6]
index函数用于从列表中找出某个值第一个匹配项的索引位置
a = [1,2,3,1] print(a.index(1)) #the result : 0
insert方法用于将对象插入到列表中
a = [1,2,3] a.insert(0,'aa') #the result : ['aa', 1, 2, 3]
pop方法会移除列表中的一个元素(默认是最后一个),并且返回该元素的值
a = [1,2,3] a.pop() #the result : [1, 2] a.pop(0)
remove方法用于移除列表中某个值的第一个匹配项
a = ['aa','bb','cc','aa'] a.remove('aa') #the result : ['bb', 'cc', 'aa']
reverse方法将列表中的元素反向存放
a = ['a','b','c'] a.reverse() #the result : ['c', 'b', 'a']
sort方法用于在原位置对列表进行排序,意味着改变原来的列表,让其中的元素按一定顺序排列
a = ['a','b','c',1,2,3] a.sort() #the result :[1, 2, 3, 'a', 'b', 'c']
enumrate
li = [11,22,33] for k,v in enumerate(li, 1): print(k,v)
find方法可以在一个较长的字符串中查找子串,它返回子串所在位置的最左端索引,如果没有则返回-1
a = 'abcdefghijk' print(a.find('abc')) #the result : 0 print(a.find('abc',10,100)) #the result : 11 指定查找的起始和结束查找位置
join方法是非常重要的字符串方法,他是split方法的逆方法,用来连接序列中的元素,并且需要被连接的元素都必须是字符串
a = ['1','2','3'] print('+'.join(a)) #the result : 1+2+3
split方法,是一个非常重要的字符串,它是join的逆方法,用来将字符串分割成序列
print('1+2+3+4'.split('+')) #the result : ['1', '2', '3', '4']
strip 方法返回去除首位空格(不包括内部)的字符串
print(" test test ".strip()) #the result :“test test”
replace方法返回某字符串所有匹配项均被替换之后得到字符串
print("This is a test".replace('is','is_test')) #the result : This_test is_test a test
index查找字符串,找到报下标索引,没找到报错
a = 'abcdefghijk' print(a.index('a')) #the result : 0 print(a.index('2')) #报错
clear方法清除字典中所有的项,这是一个原地操作,所以无返回值(或则说返回None)
d = {'name':"tom"} d.clear() print(d) #the result : {}
fromkeys方法使用给定的键建立新的字典,每个键都对应一个默认的值None
print({}.fromkeys(['name','age'])) #the result : {'age': None, 'name': None}
get方法是个更宽松的访问字典项的方法,如果访问呢字典中不存在的项时不会报错 返回:None
d = {'Tom':8777,'Jack':8888,'Fly':6666} print(d.get('Tom')) #the result : 8777 print(d.get('not_exist')) #the result : None
for循环字典的三种方法
d = {'Tom':8777,'Jack':8888,'Fly':6666} for k,v in d.items(): print(k,v) for k in d.values(): print(k) for k in d.keys(): print(k)
pop方法用于获得对应与给定键的值,然后将这个”键-值”对从字典中移除
d = {'Tom':8777,'Jack':8888,'Fly':6666} v = d.pop('Tom') print(v) #8777
update方法可以利用一个字典项更新另一个字典,提供的字典中的项会被添加到旧的字典中,如有相同的键则会被覆盖
d = {'Tom':8777,'Jack':8888,'Fly':6666} a = {'Tom':110,'Test':119} d.update(a) print(d) #the result :{'Fly': 6666, 'Test': 119, 'Jack': 8888, 'Tom': 110}
将两个列表组合成字典
keys = ['a', 'b'] values = [1, 2] print(dict(zip(keys,values))) # {'a': 1, 'b': 2}
去重 (我们可以将一个列表中重复的数据用set去重)
list_1 = [1,2,3,4,5,1,2] list_1 = set(list_1) #去重: {1, 2, 3, 4, 5} print(list_1)
交集(在我们两个列表中共有的数据)
print(list_1.intersection(list_2)) #交集: {4, 5}
并集(两个列表中的元素全部打印出来,重复元素仅打印一次) .union
print(list_1.union(list_2)) #并集: {1, 2, 3, 4, 5, 6, 7, 8}
差集(一个列表中有,而另一个没有) .difference
print(list_1.difference(list_2)) #差集:在list_1中有在list_2中没有: {1, 2, 3} print(list_2.difference(list_1)) #差集:在list_1中有在list_2中没有: {8, 6, 7
进程间互相访问数据的四种方法
注:不同进程间内存是不共享的,所以互相之间不能访问对方数据
法1: 利用Queues实现父进程到子进程(或子进程间)的数据传递
法2: 使用管道pipe实现两个进程间数据传递
法3: Managers实现很多进程间数据共享
法4:借助redis中间件进行数据共享
作用:在一个进程内,同一时刻只能有一个线程执行
说明:python多线程中GIL锁只是在cpu操作时(如:计算)才是执行的,其他都是并行的,所以比串行块很多
为了解决不同线程同时访问同一资源时,数据保护问题,而产生了GIL
GIL在解释器的层面限制了程序在同一时间只有一个线程被cpu实际执行,而不管你的程序里实际开来多少条线程
为了解决整个问题,Cpython自己定义了一个全局解释器,同一时间仅有一个线程可以拿到这个数据
import time import threading lock = threading.Lock() #1 生成全局锁 def addNum(): global num #2 在每个线程中都获取这个全局变量 print('--get num:',num ) time.sleep(1) lock.acquire() #3 修改数据前加锁 num -= 1 #4 对此公共变量进行-1操作 lock.release() #5 修改后释放
什么是协程(进入上一次调用的状态)
\1.Gevent是一个第三方库,可以轻松通过gevent实现并发同步或异步编程
\2. 在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程
\3. Greenlet全部运行在主程序操作系统进程的内部,但它们被协作式地调度。
\4. Gevent原理是只要遇到I/O操作就会自动切换到下一个协程
封装
作用
继承(代码重用)
多态(接口重用)
多态是面向对象的重要特征,简单点说:‘一个接口,多种实现
指一个基类中派生出了不同的子类,且每个子类在继承同样的方法名的同时又对父类的方法做了不同的实现
就是同一种事物表现出的多种形态
作用:简单的讲就是允许父类调用子类的方法
静态方法
\1. 作用:静态方法可以更好的组织代码,防止代码变大后变得比较混乱。
\2. 特性: 静态方法只是名义上归类管理,实际上在静态方法里访问不了类或则实例中的任何属性
\3. 静态方法使用场景:
1)我们要写一个只在类中运行而不在实例中运行的方法.
2)经常有一些跟类有关系的功能但在运行时又不需要实例和类参与的情况下需要用到静态方法.
3)比如更改环境变量或者修改其他类的属性等能用到静态方法.
4)这种情况可以直接用函数解决, 但这样同样会扩散类内部的代码,造成维护困难.
\4. 调用方式: 既可以被类直接调用,也可以通过实例调用
class Dog(object): def __init__(self,name): self.name = name @staticmethod def eat(): print("I am a static method") d = Dog("ChenRonghua") d.eat() #方法1:使用实例调用 Dog.eat() #方法2:使用类直接调用
类方法
\1. 作用:无需实例化直接被类调用
\2. 特性: 类方法只能访问类变量,不能访问实例变量
\3. 类方法使用场景: 当我们还未创建实例,但是需要调用类中的方法
\4. 调用方式: 既可以被类直接调用,也可以通过实例调用
lass Dog(object): name = '类变量' #在这里如果不定义类变量仅定义实例变量依然报错 def __init__(self,name): self.name = '实例变量' self.name = name @classmethod def eat(self,food): print("%s is eating %s"%(self.name,food)) Dog.eat('baozi') #方法1:使用类直接调用 d = Dog("ChenRonghua") d.eat("包子") #方法2:使用实例d调用
魔法方法
new : 先于__init__方法,每生成一个实例执行一次,new 类方法创建实例对象
init : __init__方法每生成一个实例就会执行一次,初始化实例对象
call : 后与__init__方法,C()() 使用类再加一个括号调用, C为类名称
del : 析构方法,删除无用的内存对象(当程序结束会自动自行析构方法)