python基础

Posted 2020-08-14

本章节内容：

1、文件基本操作

2、函数基本语法

3、collections函数

 

一、文件基本操作

#文件处理
‘‘‘
文件句柄 = open(‘文件路径‘, ‘模式‘)
打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。

打开文件的模式有：

r，只读模式（默认）。
w，只写模式。【不可读；不存在则创建；存在则删除内容；】
a，追加模式。【可读；   不存在则创建；存在则只追加内容；】
"+" 表示可以同时读写某个文件

r+，可读写文件。【可读；可写；可追加】
w+，写读
a+，同a
"U"表示在读取时，可以将 \\r \\n \\r\\n自动转换成 \\n （与 r 或 r+ 模式同使用）

rU
r+U
"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）

rb
wb
ab
‘‘‘

View Code

 

 

 

二、函数基本语法

 1、lambda表达式（简单函数）

#原实例
def func(a):
    a += 1
    return a
result = func(4)
print result

#lambda表达式，简单函数的表达方式
# 函数名  = lambda 定义变量：函数内容， 并return变量
func_1 = lambda a: a+1
ret = func_1(4)
print ret

View Code

2、def函数（参数）

#一个参数
def show(arg):
    print(arg)
show(‘kkkkk‘)

#两个参数
def show2(arg1, arg2):
    print(arg1, arg2)
show2(‘kkkk‘, ‘aaaa‘)

#默认参数,必须放在最后
def show3(arg1,arg2=999):
    print(arg1,arg2)
show3(111)
show3(111,888)

#指定参数
def show4(arg1, arg2):
    print(arg1, arg2)
show4(arg2=222, arg1=111)


#原生的例子
def show5(arg):
    print(arg)
n = [11, 22, 33, 44]
show5(n)

#动态参数--列表(list)
def show6(*args):
    print(args, type(args))
show6(11, 22, 33, 44, 55)

#动态参数--字典(dict)
def show7(**kwargs):
    print(kwargs, type(kwargs))
show7(n1=78, uu=123, bb=999)

#动态参数--组合使用
def show8(*args, **kwargs):
    print(args, type(args))
    print(kwargs, type(kwargs))
#show(11, 22, 33, 44, n1=88, alex=‘sb‘)
l = [11, 22, 33, 44]
d = {‘n1‘:88, ‘alex‘:‘sb‘}
#show8(l, d)
‘‘‘
结果：
(([11, 22, 33, 44], {‘n1‘: 88, ‘alex‘: ‘sb‘}), <type ‘tuple‘>)
({}, <type ‘dict‘>)
‘‘‘
show8(*l, **d)
‘‘‘
结果：
((11, 22, 33, 44), <type ‘tuple‘>)
({‘n1‘: 88, ‘alex‘: ‘sb‘}, <type ‘dict‘>)
‘‘‘

#.format()格式化参数使用
s1 = ‘{0} is {1}‘
l = [‘alex‘, ‘2b‘]
#result = s1.format(‘alex‘, ‘2b‘)
result = s1.format(*l)
print(result)

#字典
s2 = ‘{name} is {acter}‘
d = {‘name‘:‘alex‘, ‘acter‘:‘sb‘}
#result = s2.format(name = ‘alex‘, acter = ‘sb‘)
result2 = s2.format(**d)
print (result2)

View Code

3、内置函数

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Shu Yang Wang
#内置函数
‘‘‘
https://docs.python.org/3/library/functions.html#next
‘‘‘

#abs() 求绝对值
#all() 全部只为真，为真 all([1,2,3,4])
#any() 只要有真，为真
#ascii()
#bin()
#bool() 布尔值，真假
#bytearray()
#bytes()
#callable() 是否可调用，可执行
#chr() 把ascii码转成str
#old() 把str转成ascii码
#classmethod() 类方法，？？
#compile() 编译python代码
#complex() 复数
#delattr() 反射时候用
#dict() 字典
#dir() 路径
#divmod() ？？
#enumerate() 加给列表序列
#eval() 计算器函数
#exec() ？？
#filter() 对于序列中的元素进行筛选，最终获取符合条件的序列
#map() 遍历序列，对序列中每个元素进行操作，最终获取新的序列。
#float() float类型，双精度
#format()
#forzenset() 冻结一个不能更改的集合
#getattr()
#globals() 全局变量
#hasattr()
#hash() 哈希值
#help()
#hex() 转16进制
#id()
#input()
#int()
#isinstance()
#issubclass()
#iter()
#len()
#list()
#locals() 局部变量
#max() 最大的
#memoryview()
#min() 最小的
#next()
#object()
#oct() 八进制
#open() 打开文件
#pow() 蜜
#print()
#property()
#range() 创建一个区间
#repr() 返回字符串，
#revered() 反转
#round() 返回整数
#set()
#setattr()
#alice()
#sorted() 排序
#staticmethod()
#str()
#sum()
#super() 执行父类
#tuple()
#type()
#vars() 返回字典的key 和val
#zip() 列表结合
#__import__()

‘‘‘
1、取绝对值abs
n = abs(-1001)
print(n)
2、all,any
0,None,空字符串,空列表,空字典,空元组,bool值都是False
print(bool(0))
all中所有为真才为真
n = all([1,2,3,0])
print(n)
any中只要有真就为真
n = any([0,1,0,0,0])
print(n)
3、ascii()自动执行对象的__repr__方法
class Foo:
    def __repr__(self):
        return "65"
n = ascii(Foo())
print(n)
4、进制转换
#bin() 二进制
print(bin(23))
#oct() 八进制
print(oct(345))
#hex() 十六进制
print(hex(1111111))
5、字符串转字节bytes()
bytes(待转换的字符串, 按照什么编码)
汉字utf-8编码3个字节，GBK一个汉字两个字节，一个字节8位
#utf-8
s = "二万画画"
# 01000110 01000110 01000110 01000110 01000110 01000110 01000110 01000110 01000110 01000110 01000110 01000110
#十进制表示
# 43        43          43      43      43      43      43          43      43      43          43      43
m = bytes(s, encoding="utf-8")
m1 = bytes(s, encoding="GBK")
print(m)
print(m1)
6、字符串转换为字节列表bytearray()
m2 = bytearray(s, encoding="utf-8")
print(m2)
#字节转换为字符串,编码方式保持一致
m3 = str(m2,encoding="utf-8")
print(m3)
7、文件操作open
#打开文件
f = open(‘db‘,‘r‘)  #只读
f = open(‘db‘,‘w‘)  #只写，写之前清空文件
f = open(‘db‘,‘x‘)  #文件存在就报错；不存在创建并只写
f = open(‘db‘,‘a‘)  #追加
#操作文件
f.read()
f.readlines()
f.readline()
#关闭文件
f.close()
r+:即可读又可写，需要找到指针的位置
f = open(‘db‘, ‘r+‘, encoding="utf-8")

如果打开模式没有b，则read按照字符读取
data = f.read(3)
tell当前指针所在的位置（字节）
print(f.tell())
调整写入指针位置（字节）
f.seek(f.tell())
当前指针位置开始覆盖写入
f.write("admin")
f.close()
‘‘‘

View Code

 

 

三、collections函数

调用collections函数应先

import collections

1、计数器（counter）

　　Counter是对字典类型的补充，用于追踪值的出现次数。

　　ps：具备字典的所有功能 + 自己的功能

import collections

#传字符串，列表
obj = collections.Counter(‘fafafafafafbaababfggagagaerewrwwerwdfs‘)
print (obj)

ret = obj.most_common(4)
print (ret)

#__missing__ 对于不存在的元素，返回计数器为0

#most_common 数量大于等n的所有元素和计数器

#elements 计数器中的所有元素，注：此处非所有元素集合，而是包含所有元素集合的迭代器

#update 更新计数器，其实就是增加；如果原来没有，则新建，如果有则加一

#subtract 相减，原来的计数器中的每一个元素的数量减去后添加的元素的数量

#copy 拷贝

#__reduce__ 返回一个元组（类型，元组）

#__delitem__ 删除元素

#collections 继承dict 如items() keys() values()都有

View Code

2、有序字典(orderedDict)

　　orderdDict是对字典类型的补充，他记住了字典元素添加的顺序。

dic = collections.OrderedDict()
dic[‘k1‘] = ‘v1‘
dic[‘k2‘] = ‘v2‘
dic[‘k3‘] = ‘v3‘
dic[‘k4‘] = None
print dic

#move_to_end(‘k1‘)把k1拿到最后 python3中新加
#popitem() 默认那最后的删除
#pop(‘k2‘) 指定k2删除，有返回值v2
#setdefault(‘k4‘) 设定默认值
#update({‘k1‘:‘v111‘,‘k10‘:‘v10‘}) 有值更新，没有值添加

View Code

3、默认字典(defaultdict)

defaultdict是对字典的类型的补充，他默认给字典的值设置了一个类型。

#原生字典，判断列表大于66和小于66的数
valuses = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
my_dict = {}

for value in valuses:
    if value > 66:
        #has_key判断有没有k1这个key值
        if my_dict.has_key(‘k1‘):
            my_dict[‘k1‘].append(value)
        else:
            my_dict[‘k1‘] = [value]
    else:
        if my_dict.has_key(‘k2‘):
            my_dict[‘k2‘].append(value)
        else:
            my_dict[‘k2‘] = [value]
print(my_dict)
#结果：
#{‘k2‘: [11, 22, 33, 44, 55, 66], ‘k1‘: [77, 88, 99, 90]}
‘‘‘

dic1 = collections.defaultdict(list)
dic1[‘k1‘].append(‘alex‘)
print dic1

#方法二：
valuses = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
#默认给字典的值设置了一个类型list
my_dict = collections.defaultdict(list)

for valuse in valuses:
    if valuse > 66:
        my_dict[‘k1‘].append(valuse)
    else:
        my_dict[‘k2‘].append(valuse)
print(my_dict)
#结果：
#{‘k2‘: [11, 22, 33, 44, 55, 66], ‘k1‘: [77, 88, 99, 90]}

View Code

4、可命名元组(namedtuple)

根据nametuple可以创建一个包含tuple所有功能以及其他功能的类型。
(11,22,33,44)
0 1 2 3
老调用[0] [1] [2] [3]
name age sex fff
新调用 .name .age .sex .fff

MytupleClass = collections.namedtuple(‘MytupleClass‘,[‘x‘, ‘y‘, ‘z‘])
obj2 = MytupleClass(11, 22, 33)
print(obj2.x)
print(obj2.y)
print(obj2.z)
#结果：
#11
#22
#33

View Code

5、双向队列(deque)

一个线程安全的双向队列
注：既然有双向队列，也有单项队列（先进先出 FIFO ）

deq = collections.deque()
deq.append(‘1‘)
deq.appendleft(‘10‘)
deq.appendleft(‘1‘)
print (deq)
r = deq.count(‘2‘)
print (2)
deq.extend([‘yy‘, ‘uu‘, ‘ii‘])
deq.extendleft([‘yy1‘, ‘uu1‘, ‘ii1‘])
print (deq)
deq.rotate(1)
print (deq)

#append 添加队列
#appendleft 从左添加队列
#clear 清空队列
#copy  拷贝
#count 某个元素在队列添加多少次
#extend 扩展添加多个元素
#extendleft 从左边扩展添加多个元素
#index 取值的索引位置
#pop 右边取数据，并从队列中删除
#insert 插入
#popleft 左边取数据，并从队列中删除
#remove  删除
#reverse 反转
#rotate 把队列的尾部移动到左边

##单向队列
#python3 调用小写
import Queue
que = Queue.Queue()
que.put(‘fafa‘)
print que.qsize()
q = que.get(1)
print (q)


#qsize 查看个数
#empty 清空
#full
#put 写数据
#put_nowait
#get 拿数据
#get_nowait

View Code