Python基础语法

1.数据类型文本编码

1.基本数据类型

整数（int）、浮点数（float）、复数（complex）、布尔值（bool）

2.序列数据类型

字符串（str）、列表（list）、元组（tuple）

3.集合数据类型

集合（set）：表示无序的唯一元素集合、

冻结集合（frozenset）：表示不可变的集合

4.映射数据类型

字典（dict）

5.特殊数据类型

NoneType：表示空值，只有一个值 None

bytes ：表示字节序列。

6. 类（class）：自定义数据类型，通过创建类来实现自定义数据结构和行为。

python3默认使用unicode字符集、utf-8编码**（utf-8是根据unicode字符集编码字符或解码字符的一种方式）。**str字符串在内存中就是以unicode形式储存。因此例如要变成二进制形式存储，要使用encode编码或者以b'str'形式构造字节串。

python 复制代码

'sanDA不溜'.encode('utf-8')# 将utf-8格式数据编码为字节类型二进制数据
b'12san' #构造字节串
b'sanDA\xe4\xb8\x8d\xe6\xba\x9c'.decode('utf-8') #解码字节数据为utf-8格式

格式化输出

python 复制代码

'''法一'''
print('%s今年%.2f岁'%('我',10))
# %%表示输出%
'''法二'''
print('{0}今年{1:.2f}岁'.format('我',10.5))
'''法三'''
str = 'brt'
age = 10
print(f'{str}今年{age:.1f}岁')

2.序列

通用序列操作

索引取值 [ i ]

切片[ start : end不包括 : step]

+好拼接 [1,2,3]+[1,2,3]

乘法构造重复序列 'py'*5

in 、not in判断元素是否在序列里

len()求长度、max()、min()

2.1 list 、 tuple、str

python 复制代码

'''列表'''
lis = [1,2,3] 
# 赋值
lis[0] =1
lis[1:1]=[4]
lis[1:] = [1,8,8,7,7,4]
# 删除
del lis[0]
# 弹出并删除最后一个元素
lis.pop()
# 删除遇到的第一个元素
lis.remove(8)
# 指定下标插入
lis.insert(1,'value')
# 追加元素
lis.append(9)
# 通过追加列表追加多个元素
lis.extend([1,1,2])
# 拷贝
a = lis.copy()
# 统计元素出现次数
lis.count(8)
# 该元素第一次出现的下标
lis.index(8)
# 翻转序列
lis.reverse()
# 翻转序列返回一个迭代器对象
r = reversed(lis)
# 排序
lis= [8,7,6,9,0,1,88]
lis.sort()# 参数key=为排序标准，reverse=为排序顺序
# 排序返回新列表
s = sorted(lis)
# 清空列表
lis.clear()

python 复制代码

'''元组是不可变对象，元组不可修改，其它使用方法和list类似'''

python 复制代码

'''字符串'''
s = 'abcabccffwzcfcfabc'
# 指定字符串长度并指定字符串填充两端让原字符串居住
s1 = s.center(50,"-")
s1
# 寻找第一个子串下标，还可以指定起点终点
s.find("fwz")
# 用字符串连接字符串
s2 = '+'.join('123')
# 分割字符串
ls = '1+2+3'.split('+')
ls
# 替换子串
'abcfwz'.replace('fwz','abcd')
# 删除首尾空白符或指定字符
'  lll   \n'.strip()
'ooo   abccba   ooop'.strip('o p')

2.2 dict和set

python 复制代码

'''字典'''
# 创建
# 键key必须是不可变类型
d1 = {"name":'ggbong','age':10}
d2 = dict([('name','ggb'),('age',10)])
d3= dict.fromkeys(['name','age'],(None))
# 键索引 d[key] = value
d1['name']
# 获取值,还可以指定找不到时返回值get('key','No')
d1.get('name')
# 与get类似，但当找不到key时，自动添加该key进字典
d1.setdefault('score')
# 更新字典
d ={'name':'m'}
d.update({'name':'mm','age':23})
d
# 自动添加新items
d['weight']=58
# 返回可迭代键值对items,返回类型为一个可迭代对象
d1.items()
for k,v in d1.items():
    pass
# 返回所有键，返回类型为一个可迭代对象
d1.keys()
# 返回所有值
d1.values()
# 键值对数量
len(d1)
# 判断键是否在字典
'age' in d1
# 字符串格式化
'{name}今年{age}岁了'.format_map(d)
# 浅拷贝，拷贝后字典中其它对象例如列表仍指向原字典中的列表
c = {'name':'z','k':[1,2,3]}.copy()
# 深拷贝，拷贝后字典中其它对象例如列表与原字典中的列表地址相互独立
from copy import deepcopy
c1 = deepcopy({'name':'z','k':[1,2,3]})
# 弹出指定键的值并删除该键值对
v = d1.pop('age')
# 随机弹出并删除一个键值项
kv = d1.popitem()
# 清空字典
d2.clear()

python 复制代码

# 集合
# 集合
# set存储的是不重复的key，没有value
# 创建
s = {1,2,3}
s1 = set(['a','b','c'])
# 添加
s1.add('d')
# 删除
s.remove(3)
# 取元素
for k in s1:
    print(k)

list(s)[0]

3.函数

python 复制代码

'''定义函数'''
def fname():
    pass
'''调用函数'''
fname()
'''函数对象'''
fname() #表示调用函数fname
fname #  表示fname是一个变量，指向函数对象
'''函数参数'''
# --------位置参数
def f(x,y):
    return x+y;
# --------默认参数 ,函数定义时，默认参数的值就确定了，
# 如果默认参数指向的是例如列表，那改变的列表成为下一次调用的默认参数
def f1(x,n=2):
    return pow(x,n)
# ---------可变参数 *arg 接受并作为一个元组
def f2(*args):
    s = 0
    for i in args:
        s = s+i
    print(type(args))
    return s
l = [1,2,3]
# 调用
f2(*l)
f2(1,2,3)
# -----------关键字参数,kw接收并返回一个字典
def f3(**kw):
    for k,v in kw.items():
        print(k,': ',v)
    print(kw)
ds = {'a':1,'b':2}
f3(**ds)
f3(a=1,b=2)
# -------------限定关键字参数
#限定要出现s1,s2两个参数，可设默认参数值
def f4(*,s1,s2):
    return s1+s2
f4(s1=4,s2=5)
#前面出现可变参数可不用*分隔符
def f44(*args,s1,s2):
    return args[0]+s1+s2
f44(1,2,3,s1=4,s2=5)

# 上述参数可以组合，
# 对于任意函数，都能通过f(*args, **kw)的形式调用它

4. 异常与处理

当程序运行时发生异常Exception时，python会主动或者我们主动抛出raise异常，异常会沿着调用栈一直抛出，若没有处理方法，则会令系统终止。

python 复制代码

'''捕获异常并处理'''
# 此时如果不捕获、处理异常，则异常会一直沿着函数调用栈往外抛raise
try:
    #可能raise抛出异常的代码
    print('try...')
    r = 10 / int('2')
    print('result:', r)
except ValueError as e:
    # ValueError是Exception的一个子类，而所有异常都继承BaseException
    # except用来捕获某个（这里是ValueError）类型或它的所有继承它的的子类型的异常，
    # as 起一个别名
    # 捕获异常后，就执行该except下的语句，并跳到执行finally下语句，
    # 若没有finally则顺序执行接下的代码，系统继续运行
    print('ValueError:', e)
except ZeroDivisionError as e:
    # 同上，但第一个except捕获异常后，接下啦的except将不执行
    print('ZeroDivisionError:', e)
else:
    # 若没有抛出异常，则执行else
    # 当然也可以不写else
    print('no error!')
    # 我继续抛出不背锅，看看调用我那个函数怎么处理
    raise 
finally:
    # 无论如何都会执行，不管有没有抛出异常
    # 当然也可以没有finally
    print('finally...')
# 后续代码
pass

'''raise语句抛出错误'''
def f(x):
    pass
    if(x==0):
        # 这样某个函数调用f()时传入0便会抛出异常，捕不捕获是另一回事
        raise ValueError("sys meet ValuEerror")
    pass

# 若在except语句块中raise，则也会再像外层抛出异常
try :
    pass
except ValueError as v:
    pass
    # 抛出本次捕获的异常
    raise
except ZeroDivisionError as z:
    pass
    # 也可以抛出其它异常
    raise ValueError

'''自定义异常类'''
# 只需要继承一个异常类
class MyException(Exception):
    pass

5. 读写文件

python通过open()函数，按照某种编码打开文件。

在读写过程中，读写的数据是放在内存缓冲区的，等到close()，缓存区里数据文本才完全放到外存文件中。

python 复制代码

# 使用with,无论有没有发生异常都会自动调用f.close()关闭文件
# 'r'只读，'rb'以二级制形式读取文件
# open()还有encoding参数encoding=''，用于读取非UTF-8编码的文本文件
with open('filepath', 'r') as f:
    # 打开的文件有由f对象代表
    # f.read()就是操作文件，读取全部内容
    print(f.read())

# 'w'以写文件模式进入，'wb'写二进制
with open('w1.txt', 'w') as f:
    for i in range(10):
        # 后面不会自动加换行
        f.write('%iHello, world!'%i)

f对象是file-like Object，可以不是文件类型，像StringIO、BytesIO这样拥有read()、write()方法的也可以是f对象。

python 复制代码

from io import BytesIO
f = BytesIO(b'2a\xe4\xb8\xad\xe6\x96\x87')
f.read()
f.write(b'zfzf\xe4\xb8')
f.seek(0)# 因为此时f指向了文件末尾，需要重新指向文件开头
f.read()

from io import StringIO
f = StringIO()
f.write('china!')
f.seek(0)# 因为此时f指向了文件末尾，需要重新指向文件开头
f.read()

6. 序列化

把变量从内存中变成可存储或传输（以至于程序结束、内存被回收后所作修改或当前状态被保留）的过程称之为序列化。

Python提供了pickle模块来实现序列化。

python 复制代码

import pickle
'''序列化导出'''
s = dict(name='fz', age=22, score=88)
sb = pickle.dumps(s)
# 此时s被序列化为sb字节串
sb
# 然后你就可以通过写文件，以'wb'方式写入文件
f = open('dump.txt', 'wb')
f.write(sb)
# pickle.dump(d, f)
f.close()
#---------------也可以直接将要序列化对象dump进文件---------------------------
f = open('dump1.txt', 'wb')
pickle.dump(s, f)
f.close()
'''反序列化导入'''
# 反序列化，即导入对象进内存
f = open('dump1.txt', 'rb')
d = pickle.load(f)
f.close()
d

参考

函数的参数 - Python教程 - 廖雪峰的官方网站 (liaoxuefeng.com)