python基础操作

2021/4/28 14:57:24

编程Tag： 方法操作基础线程 name list python print result

本文主要是介绍python基础操作，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

变量的定义

在程序中，有时我们需要对2个数据进行求和，那么该怎样做呢？

大家类比一下现实生活中，比如去超市买东西，往往咱们需要一个菜篮子，用来进行存储物品，等到所有的物品都购买完成后，在收银台进行结账即可

如果在程序中，需要把2个数据，或者多个数据进行求和的话，那么就需要把这些数据先存储起来，然后把它们累加起来即可

在Python中，存储一个数据，需要一个叫做变量的东西，如下示例:

num1 = 100 #num1就是一个变量，就好一个小菜篮子

num2 = 87  #num2也是一个变量

 result = num1 + num2 #把num1和num2这两个"菜篮子"中的数据进行累加，然后放到 result变量

· 说明:

· 所谓变量，可以理解为菜篮子，如果需要存储多个数据，最简单的方式是有多个变量，当然了也可以使用一个

· 程序就是用来处理数据的，而变量就是用来存储数据的

Python3中数据类型

不可变数据：数字，字符串，元组

可变数据：列表，字典，集合

在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中间件进行数据共享

线程

线程是操作系统调度的最小单位
它被包含在进程之中，是进程中的实际运作单位
进程本身是无法自己执行的，要操作cpu，必须创建一个线程，线程是一系列指令的集合
无论你启多少个线程，你有多少个cpu,python在执行的时候同一时刻只允许一个线程执行
两个进程想通信，必须要通过一个中间代理

进程和线程区别

进程包含线程
线程共享内存空间
进程内存是独立的
进程可以生成子进程，子进程之间互相不能互相访问
在一个进程里面线程之间可以交流。两个线程想通信，必须通过一个中间代理来实现

GIL全局解释器锁:保证同一时间仅有一个线程对资源有操作权限

作用：在一个进程内，同一时刻只能有一个线程执行

说明：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 修改后释放

协程

什么是协程(进入上一次调用的状态)

协程，又称微线程，纤称，协程是一种用户的轻量级线程
协程能保留上一次调用时的状态(即所有局部状态的一个特定组合)，每次过程重入时，就相当于上一次调用的状态
协程最主要的作用就是在单线程的条件下实现并发的效果

协程为何能处理大并发(gevent遇到I/O自动切换)

\1.Gevent是一个第三方库，可以轻松通过gevent实现并发同步或异步编程

\2. 在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程

\3. Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。

\4. Gevent原理是只要遇到I/O操作就会自动切换到下一个协程

面向对象(封装，继承，多态)

封装

在类中对数据的赋值，内部调用对外部用户是透明的
这使类变成了一个容器，里面包含着类的数据和方法

作用

防止数据被随意修改
使内部程序不需要关注对象内部的构造，只需要通过对外提供的接口进行直接访问

继承(代码重用)

一个类可以派生出子类，在这个父类里定义的属性，方法自动被子类继承
使用经典类： Person.init(self,name,age) 并重写写父类Person的构造方法，实现，先覆盖，再继承，再重构

多态(接口重用)

多态是面向对象的重要特征，简单点说：‘一个接口，多种实现
指一个基类中派生出了不同的子类，且每个子类在继承同样的方法名的同时又对父类的方法做了不同的实现
就是同一种事物表现出的多种形态

作用：简单的讲就是允许父类调用子类的方法

静态方法

\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 : 析构方法，删除无用的内存对象（当程序结束会自动自行析构方法）

这篇关于python基础操作的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

python基础操作

变量的定义

Python3中数据类型

字符串常用方法

字符串常用方法

字典常用方法

集合常用方法

进程

线程

进程和线程区别

GIL全局解释器锁:保证同一时间仅有一个线程对资源有操作权限

协程

协程为何能处理大并发(gevent遇到I/O自动切换)

面向对象(封装，继承，多态)

相关编程文章