本文内容全是根据[官方文档](https://www.osgeo.cn/openpyxl/index.html#cookbook)整理。

### 1. 编写工作簿


```python
from openpyxl import Workbook
from openpyxl.utils import get_column_letter

wb = Workbook()

dest_filename = 'empty_book.xlsx'

ws1 = wb.active
ws1.title = "range names"

for row in range(1, 40):
     ws1.append(range(600))

ws2 = wb.create_sheet(title="Pi")

ws2['F5'] = 3.14

ws3 = wb.create_sheet(title="Data")

for row in range(10, 20):
       for col in range(27, 54):
            _ = ws3.cell(column=col, row=row, value="{0}".format(get_column_letter(col)))
            
print(ws3['AA10'].value)

wb.save(filename = dest_filename)
```

    AA


### 2. 读取工作表


```python
from openpyxl import load_workbook
# 加载
wb = load_workbook(filename = 'empty_book.xlsx')

# 获取sheet
sheet_ranges = wb['range names']

# 打印值
print(sheet_ranges['D18'].value)

```

    3


### 3. 使用数字格式


```python
import datetime
from openpyxl import Workbook
wb_name = 'my_one1.xlsx'
wb = Workbook()
ws = wb.active
# set date using a Python datetime
ws['A1'] = datetime.datetime(2019, 7, 21)
ws['A2'] = str(datetime.datetime.strptime("21/11/19","%d/%m/%y"))[:10]

print(ws['A1'].value)
print(ws['A2'].value)
ws['A1'].number_format

wb.save(filename = wb_name)
```

    2019-07-21 00:00:00
    2019-11-21


### 4. 使用公式


```python
from openpyxl import Workbook
wb = Workbook()
ws = wb.active
# add a simple formula

ws['A1'] = 1
ws['A2'] = 2
ws["A3"] = "=SUM(A1, A2)/2"

wb.save("formula.xlsx")
```

### 5. 合并/取消合并单元格


```python
from openpyxl.workbook import Workbook

wb = Workbook()
ws = wb.active

# 单列合并
# ws.merge_cells('A2:D2')
# ws.unmerge_cells('A2:D2')

# 多列合并
ws.merge_cells(start_row=2, start_column=1, end_row=4, end_column=4)
# ws.unmerge_cells(start_row=2, start_column=1, end_row=4, end_column=4)

wb.save("formula.xlsx")
```

### 6. 插入图片


```python
from openpyxl import Workbook
from openpyxl.drawing.image import Image

wb = Workbook()
ws = wb.active
ws['A1'] = 'You should see three logos below'
# create an image
img = Image('1.jpg')
# add to worksheet and anchor next to cells
ws.add_image(img, 'A1')
wb.save('logo.xlsx')
```

### 7. 折叠


```python
import openpyxl
wb = openpyxl.Workbook()
ws = wb.create_sheet()
ws.title = "big_data"
ws['A1'] = 234
ws['B1'] = 3234
ws['A2'] = 1234
ws['A4'] = 'A4'
ws['b9'] = 'b9'
ws.column_dimensions.group('C','D', hidden=True)
ws.row_dimensions.group(1,10, hidden=True)
wb.save('group.xlsx')
```

### 8. 只读/只写模式 

####  1. 只读


```python
from openpyxl import load_workbook
wb = load_workbook(filename='group.xlsx', read_only=True)
ws = wb['big_data']


for row in ws.rows:
    print(row)
    if len(row) >= 1:
        print(row[1].value)

```

    (<ReadOnlyCell 'big_data'.A1>, <ReadOnlyCell 'big_data'.B1>)
    3234
    (<ReadOnlyCell 'big_data'.A2>, <EmptyCell>)
    None
    ()
    (<ReadOnlyCell 'big_data'.A4>, <EmptyCell>)
    None
    ()
    ()
    ()
    ()
    (<EmptyCell>, <ReadOnlyCell 'big_data'.B9>)
    b9


#### 2. 只写


```python
>>> from openpyxl import Workbook
>>> wb = Workbook(write_only=True)
>>> ws = wb.create_sheet()
>>>
>>> # now we'll fill it with 100 rows x 200 columns
>>>
>>> for irow in range(100):
...     ws.append(['%d' % i for i in range(200)])
>>> # save the file
>>> wb.save('new_big_file.xlsx') # doctest: +SKIP
```


```python
>>> from openpyxl import Workbook
>>> wb = Workbook(write_only = True)
>>> ws = wb.create_sheet()
>>> from openpyxl.cell import WriteOnlyCell
>>> from openpyxl.comments import Comment
>>> from openpyxl.styles import Font
>>> cell = WriteOnlyCell(ws, value="hello world")
>>> cell.font = Font(name='Courier', size=36)
>>> cell.comment = Comment(text="A comment", author="Author's Name")
>>> ws.append([cell, 3.14, None])
>>> wb.save('write_only_file.xlsx')
```


python处理excel（1）

#### 1. Python中的线程 
Thread类
t = threading.Thread(target=None,name=None,args=(),kwargs=None,*,daemin=None)

target:线程调用的对象，目标函数
name：线程的名字，可以重名
args：目标函数传参，元祖
kwargs：传递关键字参数，字典

```
import threading
import  time

def worker():
    for _ in range(3):
        time.sleep(0.5)
        print("welcome mykernel")
        print("therad over")

def worker1():
    for _ in range(3):
        time.sleep(0.5)
        print("welcome mykernel......")
        print("therad over ..........")

t = threading.Thread(target=worker,name='w1')
t1 = threading.Thread(target=worker1,name='w2')
t.start()
t1.start()



```

    welcome mykernel
    therad over
    welcome mykernel......
    therad over ..........
    welcome mykernel
    therad over
    welcome mykernel......
    therad over ..........
    welcome mykernel
    therad over
    welcome mykernel......
    therad over ..........

python线程的没有特定的退出方法，
常见的退出：
1. 线程函数内语句执行完成
2. 线程函数中抛出未处理的异常

```
import threading
import  time

def worker():
    count = 0
    for _ in range(10):
        time.sleep(0.5)
        print("welcome mykernel")
        count +=1
        if count >4:
            raise Exception("count大于4异常")

t = threading.Thread(target=worker,name='w1')
t.start()


```

    welcome mykernel
    welcome mykernel
    welcome mykernel
    welcome mykernel
    welcome mykernel


    Exception in thread w1:
    Traceback (most recent call last):
      File "/root/.pyenv/versions/3.7.3/lib/python3.7/threading.py", line 917, in _bootstrap_inner
        self.run()
      File "/root/.pyenv/versions/3.7.3/lib/python3.7/threading.py", line 865, in run
        self._target(*self._args, **self._kwargs)
      File "<ipython-input-9-0fc2f50f7f96>", line 11, in worker
        raise Exception("count大于4异常")
    Exception: count大于4异常
    


**Python中的线程无优先级和线程组概念，不能被销毁、停止、挂起和恢复。**

##### 1. Thread传入参数


```
import threading
import  time

def worker(n):
    count = 0
    for _ in range(n):
        time.sleep(0.5)
        print("welcome mykernel")
        count +=1
        if count >4:
            raise Exception("count大于4异常")

t = threading.Thread(target=worker,name='w1',args=(5,))
t.start()


```

    welcome mykernel
    welcome mykernel
    welcome mykernel
    welcome mykernel
    welcome mykernel


    Exception in thread w1:
    Traceback (most recent call last):
      File "/root/.pyenv/versions/3.7.3/lib/python3.7/threading.py", line 917, in _bootstrap_inner
        self.run()
      File "/root/.pyenv/versions/3.7.3/lib/python3.7/threading.py", line 865, in run
        self._target(*self._args, **self._kwargs)
      File "<ipython-input-4-36a6bbbdc89d>", line 11, in worker
        raise Exception("count大于4异常")
    Exception: count大于4异常
    


##### 2. threading的属性和方法
current_thread():返回当前线程对象
main_thread()：返回主线程对象
active_thread()：当前处于alive状态的线程个数
enumerate()：返回所有活着的线程的列表，不包含已经终止和未开始的线程
get_ident()：返回当前线程id飞0整数

```
import threading
import  time

def worker(n):
    # 打印当前的线程
    print(threading.current_thread())
    # 打印该线程的主进程
    print(threading.main_thread())
    # 打印活着的进程数
    print(threading.active_count())
    # 打印活着进程的列表
    print(threading.enumerate())
    for _ in range(n):
        time.sleep(0.5)
        print("welcome mykernel")

print(threading.current_thread())
t = threading.Thread(target=worker,name='w1',args=(5,))
t.start()

print("T....",threading.enumerate(),'/n')
```

    <_MainThread(MainThread, started 140182288873280)>
    <Thread(w1, started 140181357197056)>
    <_MainThread(MainThread, started 140182288873280)>
    6
    [<_MainThread(MainThread, started 140182288873280)>, <Thread(Thread-2, started daemon 140181894067968)>, <Heartbeat(Thread-3, started daemon 140181885675264)>, <HistorySavingThread(IPythonHistorySavingThread, started 140181860497152)>, <ParentPollerUnix(Thread-1, started daemon 140181851318016)>, <Thread(w1, started 140181357197056)>]
    T.... [<_MainThread(MainThread, started 140182288873280)>, <Thread(Thread-2, started daemon 140181894067968)>, <Heartbeat(Thread-3, started daemon 140181885675264)>, <HistorySavingThread(IPythonHistorySavingThread, started 140181860497152)>, <ParentPollerUnix(Thread-1, started daemon 140181851318016)>, <Thread(w1, started 140181357197056)>] /n
    welcome mykernel
    welcome mykernel
    welcome mykernel
    welcome mykernel
    welcome mykernel


##### 3. thread实例的属性和方法
name ：名字标识，可以重名，使用getName(),setName()获取和设置
ident:线程id，是非0 整数，线程启动后才有id，否则为None，线程退出，此id依然可以访问，id可以重复使用
is_alive() 返回线程是否活着

```
import threading
import  time

def worker():
    count = 0
    while True:
        if (count>4):
            break
        time.sleep(0.5)
        count +=1

        print(threading.current_thread().name)
        print(threading.current_thread().ident)

t = threading.Thread(name='worker',target=worker())
t.start()
for _ in range(3):
    time.sleep(1)
    if t.is_alive():
        print('{} {} alive'.format(t.name,t.ident))
    else:
        print('{} {} dead'.format(t.name, t.ident))




```

    MainThread
    139942493099840
    MainThread
    139942493099840
    MainThread
    139942493099840
    MainThread
    139942493099840
    MainThread
    139942493099840
    worker 139941778028288 dead
    worker 139941778028288 dead
    worker 139941778028288 dead

start() 启动线程，每一个线程必须且只能执行一次该方法
run() 运行线程函数


Python的进程和线程（2）

#### 1.并行和并发
并行和并发的区别？
并行（parellel），一个人同一时刻做几件不互相干扰的事
并发（concurrency），同一时刻多个人 做同一件事
轮流做

解决高并发的办法

1. 队列（优先队列），缓冲区
2. 争抢（锁机制，独占锁），存在永远抢不到的问题
3. 预处理，缓存
4. 并行（水平扩展）
5. 提速（垂直扩展）
6. 消息中间件 (rabbitMQ)
![并行和并发](http://qiniu.mykernel.cn/%E5%B9%B6%E8%A1%8C%E5%92%8C%E5%B9%B6%E5%8F%91.jpg)

#### 2. 线程和进程
进程（process）是计算机的程序关于某数据集合行的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。

1. 进程和程序的关系
程序是源代码编译后的文件，而这些文件存放在磁盘上，当程序被操作系统加载到内存中，就是进程，进程中存放指令和数据，它是线程的容器.

2. 什么是线程
线程，也被称为轻量级进程（lwp）， 是程序执行流的最小单元;
一个标准的线程是由线程ID，当前指令指针（PC），寄存器和堆栈组成.

3. 进程和线程的关系
(1) 进程是容器提供资源;
(2) 线程是执行单元，使用进程提供的资源;
(3) 每一个进程都认为自己独占所有的计算机硬件资源;
(4) 进程之间不能随便共享数据;
(5) 同一个进程内的线程可以共享进程的资源，每一个线程拥有自己独立的堆栈.

![线程和进程](http://qiniu.mykernel.cn/%E7%BA%BF%E7%A8%8B%E5%92%8C%E8%BF%9B%E7%A8%8B.jpg)

#### 3. 线程的状态
1. 运行态（running）
该时刻，该线程正在占用cpu
2. 就绪态（ready）
可随时转换为运行态，因为其他线程正在运行而暂停，不占cpu
3. 阻塞态（blocked）
除非某些外部事件发生 ，否则不运行
4. 终止（terminated）
线程完成或退出，取消
![python线程的状态转换](http://qiniu.mykernel.cn/Python%E7%BA%BF%E7%A8%8B%E7%9A%84%E7%8A%B6%E6%80%81%E8%BD%AC%E6%8D%A2.jpg)


Python的进程和线程（1）

本文主要是整理python的基本类型，包括列表、元组、字典、字符串、bytes和集合（set）的基本操作和应用。

#### 1. list


```
### list：可变，可索引，有序（可索引），元素可重复，使用[]表示

lst = [1,3,'a',('a','b'),'mykernel']

#修改
lst[2] = 'good'
print('1.',lst)
#追加
lst.append('end str')
print('2.',lst)
#插入
lst.insert(3,'gogogog')
print('3.',lst)
#扩展新列表
lst2= ["new","list"]
lst.extend(lst2)
print('4.',lst)
tup = ('a','b')
lst.extend(tup)
print('5.',lst)
# + => list
# * => list，重复
new_list = [1,2]
old_list= [1]
new1= new_list+old_list
print('6.',new1)
new2= new_list*3
print('7.',new2)
#移除,移除找到的第一个，移除所有的如何写？
new2.remove(1)
print('8.',new2)
new2.pop(3) #移除索引为3的
print('9.',new2)
#清空
new2.clear()
#反转
lst.reverse()
print('9.',lst)
#排序
l = [1,1,2,-100]
l.sort()
print('10.',l)

### 进阶
#列表复制,浅拷贝
lst = [1,2,3,4,11,'a',[1,2,4]]
lst1 = lst
lst2 = lst.copy()
lst[6][1] = '1'
print('11.',lst1,'\n   ',lst2)  #原引用里的值改变，新列表也会变

#深拷贝
import copy
lst0 = [1,[2,3,4],5]
lst5 = copy.deepcopy(lst0)
lst0[1][1] = 21
print('12.',lst0,'\n   ',lst5) #lst0 != lst5

#随机数
import random
#从[0-9] 中随机挑选一个值
print('13,',random.randint(0,9))
print('14,',random.choice(range(10)))

#打乱列表
lst6 = copy.deepcopy(lst)
random.shuffle(lst6)
print('15.',lst,'\n   ',lst6)
```
求100以内的素数

```
# The first solution
import math
p1=[2,3,5,7]
n = 100 
for x in range(10,n):
    for i in range(2,math.ceil(math.sqrt(x))):
        if x % i == 0:
            break
    else:
        p1.append(x)
print(p1)

#The second solution
#合数一定可以分解成几个质数的乘积
import math
n = 100
lst = []
for x in range(2,n): 
    for i in lst: 
        if x % i ==0:
            break
    else:
        lst.append(x)
print(lst)

## optimize code
# 带flag判断，提高程序效率。
import math
lst = [2]
flag = False
for x in range(2,100): #x=13
    for i in p:   #p=[2,3,5,7]
        if x % i ==0:  # x%i != 0 
            flag = True
            break
        if i >= math.ceil(math.sqrt(x)): #i< math.ceil(math.sqrt(x))
            flag = False
            break
    if not flag: #flag = false  ==> true
         lst.append(x)
print(lst)
```
打印杨辉三角（ Pascal's triangle）

```
# The first solution
# 下一行和上一行的关系

triangle = [[1],[1,1]]
for i in range(2,6):
    cur = [1]
    pre = triangle[i-1]
    for j in range(len(pre)-1):
        cur.append(pre[j]+pre[j+1])
    cur.append(1)
    triangle.append(cur)
print(triangle)

#The second solution
triangle = []
n =6 
for i in range(n):
    row = [1]
    triangle.append(row)
    if i == 0:
        continue
    for j in range(i-1):
        row.append(triangle[i-1][j]+triangle[i-1][j+1])
    row.append(1)
print(triangle)

#Third option ,while
n = 6 
oldline = []
newline = [1]
print(newline)
length = 0 
for i in range(1,n):
    oldline = newline.copy()
    oldline.append(0)
    newline.clear()
    offset = 0 
    while offset <= i:
        newline.append(oldline[offset-1]+ oldline[offset])
        offset +=1
    print(newline)
    
#Third option ,for 
n = 6 
oldline = []
newline = [1]
print(newline)
length = 0 
for i in range(1,n):
    oldline = newline.copy()
    oldline.append(0)
    newline.clear()
    for j in range(i+1):
        newline.append(oldline[j-1]+ oldline[j])
    print(newline)

#Option 4

triangle = []
n = 6

for i in range(n):
    row = [1]*(i+1)
    triangle.append(row)
    if i == 0:
        continue
        
    for j in range(1,i//2+1): #n=3 开始
        val = triangle[i-1][j-1] + triangle[i-1][j]
        row[j] = val
        if i !=2j: #奇数个数的中点跳过
            row[-j-1] = val
print(triangle)
```

#### 2. 元组


```
# 元组有序（可索引），不可变，小括号()表示，可以重复，只读（不能增删改）
## 对比 list：有序（可索引），可变，使用[]表示，元素可重复
# 定义
print(tuple())
print((2,2))
print(tuple(range(1,7,2)))
```


```
t = (1,(2,),'a',[1,2],1,2,2,2,1,1,1)
print('1,',(t.index(1))) #返回找到的第一个的索引
print('2,',t.count(1)) #返回value的个数
print('3,',len(t))  #长度

#命名元组
from collections import namedtuple
point = namedtuple('_point',['x','y'])
p = point(21,12)
print('4,',p.x,p.y)

```

冒泡法排序


```
# 对列表[1,9,8,5,6,7,4,3,2]使用冒泡法进行排序，要求使用封装和解构来交换数据

lst = [1,9,8,5,6,7,4,3,2]
for i in range(len(lst)):
    for j in range(8-i):
        if lst[j]>lst[j+1]: #靠前位置的值大于靠后位置的值，前位置获取小的值。
            lst[j],lst[j+1]=lst[j+1],lst[j]
print(lst)
```

#### 3. 字符串 


```
# 元组有序（可索引），不可变，小括号()表示，可以重复，只读（不能增删改）
## 对比 list：有序（可索引），可变，使用[]表示，元素可重复
### 字符串是不可变的，有序，使用引号（单双，单双三）
```


```
str = "my name is mykernel"
lst = []

for i in str:
    lst.append(i)
print(lst)

lst2 = list(str)
print(lst2)
```


```
#其他相关操作
## split
print('1,','l love python'.split())
# split()的()中指定分隔符
# 默认使用空格作为分隔符

# maxsplit=# 可以指定分隔的次数。
print('2,','my name is  mykernel'.split('m',maxsplit=1))

##rsplit
#分隔符可以是任意字符串。
print('3,','my name is  mykernel'.rsplit('m',maxsplit=1))

#当不用maxsplit= 时候，split和rsplit效果一样，但是split效率更高。

##splitlines
l = """l love python
i am mykernel
"""
print('4,',l.splitlines())

##partition
l = """l love python"""
print('5,',l.partition(' '))

#partition() 不能不传入分隔符，只分隔一次，打印内容，为前半部分、分隔符和后半部分.

print('#'*20,'大小','#'*20) 

#upper
l = """l love python""" #转大写
l2= l.upper()
print('5,',l2)
#lower
l3 = l2.lower()  #转小写
print('6,',l3)

print('#'*20,'替换','#'*20)  
#replace 替换
str = 'i love python'
print('7,',str.replace('love python','am mykernel') ) #前边是旧的字符串，后边是新的字符串。
#控制替换的个数
str = 'i very very very love python '
print('8,',str.replace('very','非常',2))  #替换2个
```


```
print('#'*20,'去除','#'*20) 
#strip 去掉
str = '   mykernel   love  python   \n'
str2 = str.strip()
#strip 可以加其他字符串，意思就是去掉两端可以匹配到的对应的字符串
print('9,',str2)

#lstrip()只移除左侧部分;
#rstrip()只移除右侧部分。
print('#'*20,'填充','#'*20) 
print('10,','mykernel'.ljust(30))
print('10,','mykernel'.rjust(30))
print('10,','mykernel'.center(30))  #一边15个。。。。

print('11,','mykernel'.ljust(30,'+'))
print('11,','mykernel'.rjust(30,'#'))
print('11,','mykernel'.center(30,'*'))  #一边15个。。。。

print('#'*20,'查找','#'*20) 
#find() 查找返回找到的第一个的索引
str = 'i very very very love python '
print('12,',str.find('very'))
print('12,',str.find('very',5))
print('12,',str.rfind('very',4))
print('12,',str.rfind('very',-20,-1))

#index(sub[, start[, end]])
#在指定的区间，从左到右。找到返回对应的索引值，没找到返回ValueError。

#rindex(sub[, start[, end]])
#在指定的区间，从右到左。找到返回对应的索引值，没找到返回ValueError。

#count 在指定的区间，从左到右，统计子字符串sub出现的次数
str = 'i very very very love python '
print('13,',str.count('very')) 
print('13,',str.count('very',5))
print('13,',str.count('very',5,11))
```


```
#判断
#startwith()
str = 'i am mykernel,i very very very love python'
print(str.startswith('am'))
print(str.startswith('i'))

## 也可以指定范围进行匹配。
print(str.startswith('am',2,20)) #（2,20]
#endswith()
str = 'i am mykernel,i very very very love python'
print(str.endswith('am'))
print(str.endswith('python'))
```


```
print('#'*20,'拼接','#'*20) 
# +
print('1,','i'+' love'+' python')
# join
print('2,',' '.join(['i'+' love'+' python']))

print('#'*20,'格式化','#'*20) 
s = 'i love %s' #%s为格式占位符，然后再其他地方可以将参数传入并替换该占位符。
s1 = s%('python',) #将python传入，替换占位符。
print('3,',s1)

##format字符串格式化
#a. format方法可以使用花括号作为占位符，传入的参数将替换花括号。
s = 'i love {}' #{}作为占位符
s1 = s.format('python')
print('4,',s1)
# format方法的参数可以为多个，如果不在括号里指定其位置一一对应引入。
s ='i love {}, i am {}'
s1 = s.format('python','mykernel')  #按照位置传入
print('5,',s1)
# format方法可以在花括号里填入位置数字，其后的参数按照位置引入，从0号位置开始
s ='i love {1}, i am {0}'
s1 = s.format('python','mykernel')
print('6,',s1)
s ='i love {0}, i am {0}'
s1 = s.format('python','mykernel')
print('7,',s1)

#format方法可以用字符作为占位符的标志，方便识别。
s1='i love {language},i am {name}'.format(language='python',name='mykernel')
print('8,',s1)

#format方法的占位符可以混用，但是位置参数必须放在最前。
s1 = 'my name is {0},i love {language},i am {age}'.format('mykernel',language='pyrhon',age=18)
print('9,',s1)

```
说明1：

占位符的个数大于参数个数的时候，会抛出异常IndexError。
占位符的个数小于参数个数的时候，若对应的占位符能匹配到值则不报错，匹配不到值会返回异常。
当占位符出现混用的情况时，位置参数不在最前会返回异常。
说明2：

通常使用2.6或之后的版本使用format方法，2.6之前使用printf style。
在format中，需要注意的是，在2.6版本中是不能省略大括号里面的数字或者关键字。
**字符串对齐**


```
print('{0}*{1}={2:<4}'.format(3,2,2*3))  #右边4个空格
print('{0}*{1}={2:>4}'.format(3,2,2*3))
print('{0}*{1}={2:<04}'.format(3,2,2*3))
print('{:^30}'.format('centered'))  #左右各30个空格
print('{:*^30}'.format('centered')) 
```


```
## 演变过程
print('{}'.format(1))
#右对齐
print('{:>8}'.format(1))

print('{:^{}}'.format(1,11))

#格式填充^、<、>分别是居中、左对齐、右对齐，后面带宽度
```

#### 4. bytes和bytearray


```
# 元组有序（可索引），不可变，小括号()表示，可以重复，只读（不能增删改）
## 对比 list：有序（可索引），可变，使用[]表示，元素可重复
### 字符串是不可变的，有序，使用引号（单双，单双三）
#### bytes是不可变的字节序列，bytearray是可变的字节序列

```


```
# str -> bytes
str = 'abc'
bys = str.encode()
print(bys)

#bytes -> str
str1 = bys.decode()
print(str1)

#生成bytearray
bar = bytearray(1)
bar1 = bytearray(b'123')
print(bar,bar1)

#bytearray的相关方法

b = bytearray()
b.append(97)
b.append(99)
b.insert(1,98)
b.extend([65,66,67])
b.extend(bytearray(b'aavv'))
print(b)
b.remove(66)
print(b)
b.pop()
print(b)
b.reverse()
print(b)
b.clear()
print(b)
```

字符串转16进制


```
bytearray('abc'.encode()).hex()
```




    '616263'



#### 5. set


```
# 元组有序（可索引），不可变，小括号()表示，可以重复，只读（不能增删改）
## 对比 list：有序（可索引），可变，使用[]表示，元素可重复
### 字符串是不可变的，有序，使用引号（单双，单双三）
#### bytes是不可变的字节序列，bytearray是可变的字节序列
##### set叫集合，元素可变（元素需要可hash）、无序（无法索引,可以迭代）、不重复（去重？？）
```


```
#定义
s1 = {(1,),1,'1',b'1'}
print('1,',s1)

#增加元素,元素存在则什么都不做
s1.add('a')
print('2,',s1)

s1.update([1,2,3,4])  #update中为可迭代对象即可
print('3,',s1)
s1.update('str 11')  #注意字符串一个字符算一个元素
print('4,',s1)

#删除
s1.remove(1) #移除的元素不存在 报错
print('5,',s1)  
s1.discard('1') #移除的元素不存在  不报错
print('6,',s1)
print(s1.pop()) # -> item ,任意移除一个元素，s1为空报错
print('7,',s1)

#清除
s1.clear()
print('8,',s1)

#其他
#1. set 不能修改
#2. set 非线性结构不能查询
#3. set 无序，但是可以for in 迭代，无法索引

#可以使用in 或者 not in 判断元素是否存在，效率极高。因为元素为hash存放
```

    1, {1, b'1', '1', (1,)}
    2, {1, (1,), 'a', b'1', '1'}
    3, {1, 2, 3, 4, (1,), 'a', b'1', '1'}
    4, {1, 2, 3, 4, (1,), 'a', 'r', 's', ' ', b'1', '1', 't'}
    5, {2, 3, 4, (1,), 'a', 'r', 's', ' ', b'1', '1', 't'}
    6, {2, 3, 4, (1,), 'a', 'r', 's', ' ', b'1', 't'}
    2
    7, {3, 4, (1,), 'a', 'r', 's', ' ', b'1', 't'}
    8, set()

集合的运算

交差并补
#### 6. dict


```
# 元组有序（可索引），不可变，小括号()表示，可以重复，只读（不能增删改）
## 对比 list：有序（可索引），可变，使用[]表示，元素可重复
### 字符串是不可变的，有序，使用引号（单双，单双三）
#### bytes是不可变的字节序列，bytearray是可变的字节序列
##### set叫集合，元素可变（元素需要可hash）、无序（无法索引,可以迭代）、不重复（去重？？）
###### dict，k-v组合，可变，无序，key不能重复
```


```
d = {'k':'v','1':2,'aa':[1,2,3],'bb':(32,2)}
print(d)
#访问
print('1,',d['k'])
print('2,',d.get('ss',6))  #6为设置的默认值（可省），k不存在则返回默认值
print('3,',d.setdefault('k',5))  #5为设置的默认值（可省），如果key不存在则添加kv对

print('1，',d)

#添加
d['new'] = 44  #key存在就修改，不存在就添加
print('2，',d)

d.update({'new1':1,"new2":2})  #添加一个对象，只能是字典
d.update(red=1)
d.update((('red1',1),))
print('3，',d)

#删除
d.pop('k')  #key存在就删除并返回value，不存在返回默认值，无默认值报错
d.popitem() #随机删除一个kv对，dict为空则报错
print('4，',d)

#清空
d.clear()
print('5，',d)
```

    {'k': 'v', '1': 2, 'aa': [1, 2, 3], 'bb': (32, 2)}
    1, v
    2, 6
    3, v
    1， {'k': 'v', '1': 2, 'aa': [1, 2, 3], 'bb': (32, 2)}
    2， {'k': 'v', '1': 2, 'aa': [1, 2, 3], 'bb': (32, 2), 'new': 44}
    3， {'k': 'v', '1': 2, 'aa': [1, 2, 3], 'bb': (32, 2), 'new': 44, 'new1': 1, 'new2': 2, 'red': 1, 'red1': 1}
    4， {'1': 2, 'aa': [1, 2, 3], 'bb': (32, 2), 'new': 44, 'new1': 1, 'new2': 2, 'red': 1}
    5， {}


遍历字典


```
d = {'1': 2, 'aa': [1, 2, 3], 'bb': (32, 2)}
#打印k
for k in d.keys():
    print(k)
print('='*40)
#打印value
for v in d.values():
    print(v)
print('='*40)   
#遍历items
for it in d.items():
    print(it)
print('='*40)     
for k,v in d.items():
    print(k,v)  #接轨
```

    1
    aa
    bb
    ========================================
    2
    [1, 2, 3]
    (32, 2)
    ========================================
    ('1', 2)
    ('aa', [1, 2, 3])
    ('bb', (32, 2))
    ========================================
    1 2
    aa [1, 2, 3]
    bb (32, 2)


有序字典


```
from collections import OrderedDict
od = OrderedDict()
od['k'] = 'v'
od
```




    OrderedDict([('k', 'v')])


习题1. 用户输入一个数字，打印每一位数字及其重复的次数

```
str = "11gghhbsdsa"
d = {}
for i in str:
    d[i] = str.count(i)

print(d)
```

    {'1': 2, 'g': 2, 'h': 2, 'b': 1, 's': 2, 'd': 1, 'a': 1}

习题2.  数字重复统计：
1.随机产生100个整数
2. 数字的范围[-1000,1000]
3. 降序序输出所有不同的数字及其重复的次数

```
import random
lst = random.choices(range(-50,51),k=100)
d = dict(zip(lst,[0]*10))

for k in d.keys():
    d[k] = lst.count(k)

sorted(d.items(),key = lambda x:x[1],reverse=True)
```




    [(20, 6), (-17, 4), (-30, 3), (41, 3), (-19, 2), (-1, 2), (-47, 2), (-9, 1)]

python基础知识1

#### 1. 封装与解构 


```
a = 4
b = 5
print(a,b)
a,b = b,a
print(a,b)
```


```
#简单模式
lst = [1,3,(4,4)]
a,b,c = lst
print(a,b,c)

#进阶
a,b,(c,d) = lst
print(a,b,c,d)

tup= (1,2,3)
a,b,c = tup
print(a,b,c)

#_丢弃
#*批量收集
tup= (1,2,3,4,5,6,7,8)
a,b,c,*d,_ = tup
print(*d)
```

#### 2. 线性结构
线性结构：列表、元组、字符串、bytes、bytearray 

线性结构的特点：
1. 可以for... in 
2. 可以len()获取长度
3. 可以通过下标访问
4. 可以切片
5. 查询的时间复杂度为O(n)

非线性结构：
set、dict
元素(dict的key)要求可以hash，查询的时间复杂度为0(1)


```
# sequence[start:stop:step]
str = 'mykernel'
print(str[1])
print(str[:])
print(str[:-1])
print(str[:-1:2])
print(str[::-1])  #倒序打印
lst =list(str)
print(lst[::-1])
print(bytearray(b'www.mykernel.cn')[-10:-4:2])
```

#### 3. 时间相关操作


```
import datetime
import time

#格式化
dt1 = datetime.datetime.strptime("21/11/19 14:33",'%d/%m/%y %H:%M')
dt2 = datetime.datetime.strptime("20/11/19 16:30",'%d/%m/%y %H:%M')
print(type(dt1))

#求时间差值
delta = dt1 - dt2
print(type(delta))
print(delta)

#将时间差换算为秒
delta_seconds = delta.total_seconds()
print(delta_seconds)

#sleep
time.sleep(2)
print('sleep 2s')
```

####  4. 列表解析式
[返回值 for 元素 in 可迭代对象 if 条件]

```
print([i for i in range(10) if i > 3])
print([(x,y) for x in 'asf' for y in range(2)])
```

#### 5. 生成器表达式 
把列表解析器的[]换成() 就成为了生成器表达式，可以使用next()逐个取值。
内存占用少，计算速度“快”

```
lst = (i for i in range(10) if i > 3)
next(lst)
```
生成器表达式，逐行取值，延迟计算。但是如果取值超出个数则会报错。
#### 6. 集合表达式 
把列表解析器的[]换成{} 就成为了生成器表达式。快速生成一个set。

```
{i for i in range(10) if i > 3}
```

#### 7. 字典解析式 
{返回值 for 元素 in 可迭代对象 if 条件}  
{k:v 生成k 和 v}

```
{x:y for x in range(10) for y in [0]}
```


```
{x:0 for x in range(10)}
```


```
dict(zip(range(10),[0]*10))
```


```
list(reversed('str'))
```


```
''.join(list(reversed('str')))

```

#### 8. 内建函数

id函数


```
a = 'abc'
print(id(a))
b  = 'abc' 
print(id(b))

#数字，字符串这种常量，在python中的位置是不变的，无论被谁引用，其引用的地址是一样的。

def add(a,b):
    return a + b

print('add function:',id(add))

lst = [1,2,3]
lst1 = [1,2,3]
print('list:',id(lst))
print('list1:',id(lst1))

#函数、字典、列表等类型在内存中的位置是变化的。每次定义所分配的内存地址不一样。
```

hash函数


```
hash(a)

#列表,字典,集合是无法hash的，因为使用id查看内存地址时候是变化的，，
```

类型转换


```
#1.字符串转列表
str = "acd"
str_list = list(str)
print('str==>list:',str_list)

#2. “字符串列表”转字符串
lst = ['a','v','k']
list_str = ''.join(lst)
print('list==>str:',list_str)

#3. 字符串转元组
lst = 'accd'
str_tup = tuple(lst)
print('str==>tup：',str_tup)

#4. 字符串转字典的k，v取默认值
lst = 'accd'
print(dict)
str_dv = dict(zip(lst,[0]*len(lst)))
print('str==>dict[k]：',str_dv)

#元组转列表
t = ('a', 'c', 'c', 'd')
print(list(t))

#列表转元组
lst = ['a', 'c', 'c', 'd']
print(tuple(lst))

#列表转set，元组转set 去重。。
t = (1,1,1,1)
print(set(t))

#含有二元组的列表转字典
str = 'mykernel'
lst = [i for i in enumerate(str)]
d = {}
for i in  lst:
    d[i[0]] = i[1]

print(d)

# 字典的kv 互换
print('v<==>k:',dict(zip(d.values(),d.keys())))

lst = [1,1,1,2]
print(set(lst))

#typt 查看对象的类型
print('type :',type(type))



```

输入函数input


```
ipt = input('请输入一个字符或者数字，默认返回一个字符串')
print(type(ipt))
```

打印函数


```
print('a','b',sep='\n')  

#sep = 改变打印元组之间的格式
```

长度计算


```
len('acffsd  '*10)
```

类型确定


```
a = 2
isinstance(a,(str,int,list)) 
```
sorted(iter,[,key][,reverse])

```
print(sorted({'c':1, 'b':2, 'a':1}))
print([i for i in reversed(sorted({'c': 1, 'b': 2, 'a': 1}.items(), key=lambda x: x[1]))])
print(sorted({'c': 1, 'b': 2, 'a': 1}.items(), key=lambda x: x[1],reverse=True))

```

reversed（seq） 返回一个迭代器

enumerate(seq,start=0) 枚举

iter(iter) next(iterator)  生成一个迭代器和取迭代器里的元素

zip() 拉链函数


```
dict1 = {'name':'pxr','age':'20'}

ops = {'age':int}

info = {k:ops.get(k,lambda x:x)(v) for k,v in dict1.items()}

#lambda
#字典解析式
#get
info
```
