关于python:python基础入门

39次阅读

共计 4926 个字符,预计需要花费 13 分钟才能阅读完成。

Python 根底

python 属于解释性的高级语言

6 个规范数据类型

1、Numbers(数字)

int:整数 eg:1,2,-3,4,……

float:小数 eg:0.1,1.0,……

2、String(字符串)

用双引号、单引号、三引号界定。三引号界定能够跨行,个别用于阐明正文
eg:’a’,'”python”‘,” 根底 ”

3、List(列表)

列表由方括号界定,元素间用逗号分隔
eg:[0,’python’,’ 入门 ’,[‘p’,’y’,’t’]]、[1]

4、Tuple(元组)

元组由圆括号界定,元素间用逗号分隔,当只有一个元素时元素后逗号必须加上。
eg:(1,)、(1,2,3)

5、Dictionary(字典)

字典由大括号界定,元素是键值对模式,逗号分隔.
eg:{‘ID’:’9527′,’name’:’ 华安 ’}

6、Set(汇合)(因为之前接触较少,就略微写多了一点笔记)

与数学上的汇合一样,汇合内每一个值都是惟一的。
eg:{1, 2, 3, 4, 5}

6.1 汇合的操作
6.1.1 汇合增加

汇合的增加有两种形式,别离是 add 和 update。然而它们在增加元素时是由区别的:

add()办法

把要传入的元素作为一个整体增加到汇合中,如:

>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> s.add('two')
>>> s
{'e', 'two', 'o', 'n'}
update()办法

是把要传入的元素拆分成单个字符,存于汇合中,并去掉反复的字符。能够一次增加多个值,如:

>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> s.update('two')
>>> s
{'e', 'n', 't', 'w', 'o'}
6.1.2 汇合删除

汇合的删除操作应用的办法跟列表是一样的,应用的也是 remove 办法。如:

setVar.remove(element)

setVar : 为一个 set 类型的变量
element : 示意要查找并删除的元素
函数作用:
在汇合 setVar 中查找 element 元素,如果存在则删除;如果没找到,则报错。

>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> s.remove('e')
>>> s
{'n', 'o'}
setVar.discard(element)

setVar : 为一个 set 类型的变量
element : 示意要查找并删除的元素
函数作用:
在汇合 setVar 中查找 element 元素,如果存在则删除;如果没找到,则什么也不做。

>>> sList
set([1, 2, 3, 4, 5])
>>> sList.discard(1)
>>> sList
set([2, 3, 4, 5])
s.pop()

s:为 set 类型的变量
函数作用:
删除并返回 set 类型的 s 中的一个不确定的元素,如果为空引发 KeyError 谬误。

>>> sList
set([2, 3, 4, 5])
>>> sList.pop()
2
s.clear()

s:set 类型的变量
函数作用:
清空 s 汇合中的所有元素

>>> sList
set([3, 4, 5])
>>> sList.clear()
>>> sList
set([])
6.1.3 汇合的遍历

汇合的遍历跟序列的遍历办法齐全一样。

>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> for i in s:
    print(i)
... ... 
e
o
n
>>> 
另一种遍历形式:>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> for idex,i in enumerate(s):
        print (idex,i)
... ... 
0 e
1 o
2 n
>>> 
变量 idex 示意汇合中元素 i 的索引。
6.1.4 汇合其余办法
函数 阐明
len(s) set 的长度
x in s 测试 x 是否是 s 的成员
x not in s 测试 x 是否不是 s 的成员
s.issubset(t) 测试是否 s 中的每一个元素都在 t 中
s.issuperset(t) 测试是否 t 中的每一个元素都在 s 中
s.union(t) 返回一个新的 set 蕴含 s 和 t 中的每一个元素
s.intersection(t) 返回一个新的 set 蕴含 s 和 t 中的公共元素
s.difference(t) 返回一个新的 set 蕴含 s 中有然而 t 中没有的元素
s.symmetric_difference(t) 返回一个新的 set 蕴含 s 和 t 中不反复的元素
s.copy() 返回 set“s”的一个浅复制
6.1.5 汇合的一些操作符

既然是汇合,那就会遵循汇合的一些操作方法,如求交加、并集、差集等。

交加

Python 中求汇合的交加应用的符号是“&”,返回连个汇合的独特元素的汇合,即汇合的交加。

>>> st1 = set('python')
>>> st1
set(['h', 'o', 'n', 'p', 't', 'y'])
>>> st2 = set('htc')
>>> st2
set(['h', 'c', 't'])
>>> st1 & st2
set(['h', 't'])
并集(合集)

Python 中求汇合的并集用的是符号“|”,返回的是两个汇合所有的并去掉反复的元素的汇合。

>>> st1
set(['h', 'o', 'n', 'p', 't', 'y'])
>>> st3 = set('two')
>>> st3
set(['o', 't', 'w'])
>>> st1 | st3
set(['p', 't', 'w', 'y', 'h', 'o', 'n'])
差集

Python 中差集应用的符号是减号“-”。

>>> st1
set(['1', '3', '2', '5', '4', '7', '6'])
>>> st2 = set('4589')
>>> st2
set(['9', '8', '5', '4'])
>>> st1 - st2
set(['1', '3', '2', '7', '6'])

返回的后果是在汇合 st1 中但不在汇合 st2 中的元素的汇合。

6.1.6 汇合的不同

查看两个汇合的不同之处,应用的 difference 函数,等价于差集。如:
s1.difference(s3)
这种不同指的是汇合 s3 绝对于汇合 s1,不同的中央,也就是所有在汇合 s1 中,而不再汇合 s2 中的的元素组成的新汇合。

>>> s1
set([1, 2, 3, 4, 5])
>>> s2
set([1, 2, 3, 4])
>>> s1.difference(s2)
set([5])
>>> s3
set(['1', '8', '9', '5'])
>>> s1.difference(s3)
set([1, 2, 3, 4, 5])
6.1.7 汇合的范畴判断

汇合能够应用大于(>)、小于(<)、大于等于(>=)、小于等于(<=)、等于(==)、不等于(!=)来判断某个汇合是否齐全蕴含于另一个汇合,也能够应用子父集判断函数。

定义三个汇合 s1,s2,s3:

>>> s1=set([1, 2, 3, 4, 5])
>>> s2=set([1, 2, 3, 4])
>>> s3=set(['1', '8', '9', '5'])
大于(>)或大于等于(>=)>>> s1 > s2
True
>>> s1 > s3
False
>>> s1 >= s2
True
  示意右边汇合是否齐全蕴含左边汇合,如汇合 s1 是否齐全蕴含汇合 s2。小于(<)或 小于等于(<=)>>> s2 < s1
True
>>> s1 < s3
False
>>> s3 < s1
False
  示意右边的汇合是否齐全蕴含于左边的汇合,如汇合 s1 是否齐全蕴含于汇合 s2。等于(==)、不等于(!=)>>> s1 == s2
False
>>> s2 == s3
False
>>> s1 != s2
True
  判断两个汇合是否完全相同。
6.2 不可变汇合 frozenset

Python 中还有一种不可扭转的汇合,那就是 frozenset,不像 set 汇合,能够减少删除汇合中的元素,该汇合中的内容是不可扭转的,相似于字符串、元组。

>>> f = frozenset()
>>> f
frozenset([])
>>> f = frozenset('asdf')
>>> f
frozenset(['a', 's', 'd', 'f'])
>>> f = frozenset([1,2,3,4])
>>> f
frozenset([1, 2, 3, 4])
>>> f = frozenset((1,2,3,4))
>>> f
frozenset([1, 2, 3, 4])
>>> f = frozenset({1:2, 'a':2, 'c':3})
>>> f
frozenset(['a', 1, 'c'])

7. 数据类型汇总

list、tuple、dict,set 这四种数据类型的元素能够是任意类型
有序序列:list、tuple、string,能够用索引
不可变类型:Numbers、String、tuple
set 尽管是可变类型,然而不能更改 set 中不可变类型数据

循环

for

while

条件语句

==:恒等

!=:不等于

‘>’ : 大于

‘<’:小于

‘>=’:大于等于

‘<=’:小于等于

not:非

and:与

or:或

文件 I /O

权限:r、w、a

open():操作文件

异样

try:执行失常代码

except:产生异样,执行此处代码

else:(可不加),无异样,则执行此处代码

导包

import…… 导入

from……import…… 从……导入

面向过程编程

定义方法:

def  func_name():return                 # 可省略

面向对象编程

两个概念:class(类)和 Instance(实例)

能够继承多个基类

线程跟过程

过程间变量独立互不影响。一个过程中的多个线程共用一套变量,因而须要引入线程锁机制(Lock),保障线程间在操作过程中,不能同时对同一变量进行操作。

过程

过程池(Pool)

过程池默认参数是 CPU 核数

import random
import time
from multiprocessing import Pool


def random_time_task(name):
    print(f'执行工作 -{name}')
    start_time = time.time()
    time.sleep(random.random() * 5)
    end_time = time.time()
    print(f'工作 -{name} 执行工夫:{end_time - start_time}')


if __name__ == '__main__':
    pool = Pool(4)
    for i in range(6):
        pool.map_async(random_time_task, (i,))

    pool.close()
    pool.join()
    print('所有过程实现')

线程

开启一个新线程并返回其标识。线程执行函数 function 并附带参数列表 args (必须是元组)。可选的 kwargs 参数指定一个关键字参数字典。

import random
import threading
import time

ls = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
balance = 10
lock = threading.Lock()


def operation2balance(money):
    global ls
    global balance
    ls.append(30)
    balance = balance + money
    balance = balance - money
    time.sleep(random.random())
    ls.remove(30)
    print(len(ls))


def new_thread(n):
    for i in range(20):
        # operation2balance(n)  # 验证没有加锁两个线程同时拜访一个变量的状况
        # 操作前先取得锁
        lock.acquire()
        try:
            operation2balance(n)
        finally:
            # 操作后开释锁
            lock.release()


if __name__ == '__main__':
    t1 = threading.Thread(target=new_thread, args=(29,))
    t2 = threading.Thread(target=new_thread, args=(18,))
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print(balance)
_thread
_thread.start_new_thread(function,args[kwargs])

# 新建线程并运行

正文完
 0