# 交换两个数据
a, b = b, a
# 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）
# 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）
e.g
字符串不能被改变, 向一个索引位置赋值，比如word[0] = 'm'
会导致错误
# input 等待用户输入
input('\nPress Enter to exit.')
# isinstance 判断类型,认为子类是一种父类类型
isinstance(a, int) # True
type(a) # np.int8
# list
list = ['a', 'b']
a = list * 2 # ['a', 'b', 'a', 'b']
b = list + list[1] # ['a', 'b', 'a']
# tuple 元组
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
# set
a = set('abracadabra') # 创建set
b = set('alacazam')
print(a - b) # a 和 b 的差集
print(a | b) # a 和 b 的并集
print(a & b) # a 和 b 的交集
print(a ^ b) # a 和 b 中不同时存在的元素
# dict
d = {}
d['one'] = "1"
d['two'] = "2"
dd = {'name': 'francis', 'code': 1996, 'site': 'francislucien2017'}
a = dd.keys() # dict_keys(['name', 'code', ''site])
b = dd.values() # dict_values(['francis', 1996, 'francislucien2017'])
# 类型转换
float(x)
int(x)
str(x)
list(x)
tuple(x)
dict(x)
set(x)
chr(x) # char
ord(x) # 整数值
hex(x) # 16进制
oct(x) # 8进制
eval（str) # 用来计算str中的有效Python表达式,并返回一个对象
repr(x) # 将对象 x 转换为表达式字符串
# linux交互式编程
$ python3
>> > print("hello world!")
# linux脚本式编程
chmod + x
hello.py # 使.py文件有执行权
./ hello.py # 编译执行.py
# 或者
python3
hello.py # 输出 hello world!
# 位运算符
a = 0011
1100
b = 0000
1101
c = a & b # 0000 1100
c = a | b # 0011 1101
c = a ^ b # 0011 0001
c = ~a # 1100 0011
# 逻辑运算符
and / or / not
# 成员运算符
in / not in
print('a' in alist) # True
print('a' not in alist) # False
# 身份运算符
is / is not
id(x) == id(y) / id(a) != id(b)
print(a is b) # False
print(a is not b) # True
# 数字
number = 0xA0F # 十六进制2575
number = 0o37 # 八进制31
complex(x) # 将x转换到一个复数，实数部分为 x，虚数部分为 0
complex(x, y) # 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y，x 和 y 是数字表达式
# // 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系
7 // 2.0 # 3.0
# 在交互模式中，最后被输出的表达式结果被赋值给变量 _
tax, price = 0.1, 100
price * tax # 10.0
price + _ # 110.0
# 随机数函数
random.choice(range(10)) # 从0到9中随机挑选一个整数
uniform(x, y) # 随机生成下一个实数，它在[x,y]范围内
shuffle(lst) # 将序列的所有元素随机排序
random() # 随机生成下一个实数，它在[0,1)范围内
# 三角函数
sin / cos / tan
asin / acos / atan # 反三角函数
degrees(x) # 弧度转角度
radians(x) # 角度转弧度
np.pi / e # 常量
# 格式化字符串
print("我叫 %s 今年 %d 岁!" % ('小明', 10))
# 字符串常用内建函数
str.capitalize() # 将字符串的第一个字符转换为大写
str.center(width, fillchar) # 返回指定宽度 width 居中的字符串，fillchar 为填充的字符(默认空格)
str.count(str) # 返回 str 在 string 里面出现的次数
str.startswith(substr) # boolean
str.endswith(suffix) # boolean
str.find(str) # 返回索引或-1（没找到）
str.isalnum() # 如果字符串至少有一个字符且所有字符都是字母或数字则返回 True
str.isalpha() # 如果字符串至少有一个字符并且所有字符都是字母则返回 True
str.isdigit() # 如果字符串只包含数字则返回 True 否则返回 False
str.islower() # 如果字符串中包含至少一个区分大小写的字符，并且所有字符都是小写，则返回 True
str.isupper() # 与str.islower() 相反
str.isnumeric() # 如果字符串中只包含数字字符，则返回 True，否则返回 False
str.isdecimal() # 检查字符串是否只包含十进制字符，如果是返回 true
str.isspace() # 如果字符串中只包含空白，则返回 True，否则返回 False
len(str) # 返回长度
str.lower() / str.upper() # 转小写 / 大写
min(str) / max(str) # 返回字符串中的最小 / 最大 的字母
str.join()
s = "-"
seq = ("r", "u", "n", "o", "o", "b")
print(s.join(seq)) # r-u-n-o-o-b
str.strip([chars]) # 分别执行 lstrip 和 rstrip
# str.lstrip() 返回截掉字符串左边的空格或指定字符后生成的新字符串
str = " this is string example....wow!!! ";
print(str.lstrip()); # this is string example....wow!!!
str = "88888888this is string example....wow!!!8888888";
print(str.lstrip('8')); # this is string example....wow!!!8888888
# str.rstrip() # 删除字符串字符串末尾的空格
string.replace(str1, str2) # 将string中的str1替换为str2
string.split(str) # 以str为分隔符分割字符串
str.swapcase() # 将字符串中大写转换为小写，小写转换为大写
str.tile() # 所有单词都是以大写开始，其余字母均为小写
# 列表
del lst[2] # 删除lst的第三个元素
a = lst[-2] # 访问lst的倒数第二个元素
lst.count(a) # 计数a在lst中出现的个数
lst.extend(seq) # 在列表末尾一次性追加另一个序列中的多个值, 用新列表扩展原来的列表
lst.insert(idx, a) # 将a插入在idx位置
lst.append(a) # 末尾添加
lst.pop() # 删除末尾元素
lst.remove(a) # 删除lst中第一个a元素
lst.sort(reverse=False)
lst.clear()
a = lst.copy()
a = copy.copy(lst) # 重新开辟内存
lst = [i for i in range(15)]
print(lst[::2]) # [0, 2, 4, 6, 8, 10, 12, 14], 即 lst[start:end:span]
li = ['a', 'b', 'mpilgrim', 'z', 'example']
a = li[1:-1] # ['b', 'mpilgrim', 'z']
# 元组 元素不可修改，但可以连接组合
# 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用
tup1 = (50) # int
tup2 = (50,) # tuple
tup_x = tup_a + tup_b # 连接
len(tup)
tup * 4
a in tup
for x in tup: print(x)
# 字典
dict.clear() # 清空
del dict # 删除
# 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
str(dict) # 输出字典
key in dict # 如果键在字典dict里返回true，否则返回false
obj = dict.popitem() # 删除最后一个键和值，并返回
value = dict.pop(key) # 删除key对应的value
# 集合 （无序）
# 可以使用大括号 { } 或者 set() 函数创建集合，空集合只能是set()
s = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
s.add(x)
s.update(x, y, z) # 添加元素，且参数可以是列表，元组，字典等
s.remove(x)
s.discard(x) # 移除集合中的元素，且如果元素不存在，不会发生错误
s.pop() # 随机删除集合中的一个元素
s.clear()
x in s # boolean
z = x.difference(y) # 差集
z = x.union(y) # 并集
result = x.union(y, z) # 多集合并集
# 基本语句
for i in range(0, 10, 3):
print(i) # 0 3 6 9
# 迭代器
lst = [1, 2, 3, 4]
it = iter(lst)
a = next(it) # 1
b = next(it) # 2
for x in it:
print(x, end=' ')
import sys
while True:
try:
print(next(it))
except StopIteration:
sys.exit()
# 类迭代器
class MyNumber:
def __iter__(self):
self.a = 1
return self
def __next__(self):
if self.a <= 20:
self.a += 1
return x
else:
raise StopIteration
myclass = MyNumber
myiter = iter(myclass)
for x in myiter:
print(x) # 1 2 3 4 5 6 7 ... 19 20
# 生成器（使用了 yield 的函数被称为生成器（generator））
# 生成器是一个返回迭代器的函数，只能用于迭代操作
# 每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行
import sys
def fibonacci(n):
a, b, counter = 0, 1, 0
while True:
if counter > n:
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # f是一个迭代器，由生成器返回生成
while True:
try:
print(next(f), end=' ')
except StopIteration:
sys.exit()
# 匿名函数lambda，主体是一个表达式
sum = lambda a, b: a + b
sum(10, 20) # 30
# 全局变量
num = 1
def fun1()
global num # 关键字global
num = 123
print(num) # 1
fun1()
print(num) # 123
# 将列表当作队列使用(当栈就是 append和pop )
from collections import deque
queue = deque(["Eric", "John", "Michael"])
q = queue.popleft() # Eric
# 列表推导式
a = [x * y for x in vec1 for y in vec2]
# 字典推导式
dict = {x: x ** 2 for x in (2, 4, 6)} # {2: 4, 4: 16, 6: 36}
for x, y in dict.items():
print(x, y) # 2 4 4 16 6 36
# enumerate 同时获得序号索引和元素值
lst = ['a', 'b']
for i, item in enumerate(lst):
print(i, item) # 0 'a' 1 'b'
# zip 组合多个序列
questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
print('What is your {0}? It is {1}.'.format(q, a))
>> > What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
# 反向遍历
for i in reverse(range(10)):
print(i) # 9 8 7 6 5 4 3 2 1 0
# 排序
basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for f in sorted(set(basket)):
print(f)
# __name__：在模块被引入时，模块中的某一程序块不执行，可以用__name__属性来使该程序块仅在该模块自身运行时执行
if __name__ == '__main__':
print('程序自身在运行')
# str()： 函数返回一个用户易读的表达形式
# repr()： 产生一个解释器易读的表达形式( 函数可以转义字符串中的特殊字符 )
s = 'Hello, Runoob'
str(s) # 'Hello, Runoob'
hellos = repr(hello) # 'hello, runoob\n'
# print('{}网址： "{}!"'.format('博客', 'www.csdn.com'))
>> > 博客网址：www.csdn.com
# 应该更多的使用 str.format()
# 键盘输入
str = input("请输入：");
print("你输入的内容是: ", str)
>> > 请输入：CSDN
你输入的内容是: CSDN
# 读、写文件
open(filename, mode)
mode:
r # 只读(default)
rb # 二进制读
r + # 打开一个文件用于读写。文件指针将会放在文件的开头
w # 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件
wb # 二进制，其余同上
w + # 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件
a # 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾
ab # 以二进制格式打开一个文件用于追加
a + # 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写
ab + # 二进制，其余同上
f = open("/tmp/foo.txt", "w")
f.write("Python is fantastic\nYes!!\n")
f.close()
# f.read()为 读取一定数目的数据, 然后作为字符串或字节对象返回
f = open("/tmp/foo.txt", "r")
str = f.read() # Python is fantastic
Yes!!
print(str)
f.close()
# f.readline() 会从文件中读取单独的一行。
# 换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行
f = open("/tmp/foo.txt", "r")
str = f.readline()
print(str) # Python is fantastic
f.close()
# f.readlines() 将返回该文件中包含的所有行
f = open("/tmp/foo.txt", "r")
str = f.readlines()
print(str) # ["Python is fantastic\n", "Yes!!\n"]
f.close()
# 迭代文件，简单, 但是并没有提供一个很好的控制
f = open("/tmp/foo.txt", "r")
for line in f:
print(line, end='')
f.close()
# f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。
f = open("/tmp/foo.txt", "w")
num = f.write("Python is fantastic\nYes!!\n")
print(num) # 26
f.close()
# 如果要写入一些不是字符串的东西, 那么将需要先进行转换:
f = open("/tmp/f.txt", "w")
value = ('www.csdn.com', 14)
s = str(value)
f.write(s)
f.close()
# f.tell()
# f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数
# 如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数
>> > f = open('/tmp/foo.txt', 'rb+')
>> > f.write(b'0123456789abcdef')
16
>> > f.seek(5) # 移动到文件的第六个字节
5
>> > f.read(1)
b'5'
>> > f.seek(-3, 2) # 移动到文件的倒数第三字节
13
>> > f.read(1)
b'd'
# 处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件
with open('/tmp/foo.txt', 'r') as f:
read_data = f.read() # 不用再写f.close()
# pickle模块实现了数据序列和反序列化,能够将程序中运行的对象信息保存到文件中去，永久存储,且可以从文件中创建上一次程序保存的对象
pickle.dump(obj, file, [, protocol])
x = pickle.load(file)
# case 1:
import pickle
output = open('data.pkl', 'wb')
selfref_list = [1, 2, 3]
# Pickle dictionary using protocol 0.
pickle.dump(data1, output)
# Pickle the list using the highest protocol available.
pickle.dump(selfref_list, output, -1)
output.close()
# case 2:
import pickle
plk_file = openc('data.pkl', 'rb')
data1 = pickle.load(pkl_file)
pprint.pprint(data1)
data2 = pickle.load(pkl_file)
pprint.pprint(data2)
pkl_file.close()
# file
open(file, mode='r') # default mode: 't' 文本模式
file.close()
file.next() # next line
file.read([size])
file.readline([size])
file.readlines([sizeint])
file.seek(offset) # 设置当前位置
file.tell() # 返回当前位置
file.write(str)
file.writelines(seq)
# os 模块
os.chdir(path) # 改变当前工作路劲
os.chmod(path, mode) # 改变权限
os.close(fd) # 关闭文件表述符fd
os.getcwd() # 返回当前目录
os.link(src, dst) # 链接
os.mkdir(path, [mode]) # 创建文件夹
os.open(file, flags, mode) # 打开文件
os.remove(path) # 删除文件（文件夹报错）
os.removedirs(path) # 递归删除文件夹
os.rename(src, dst) # 重命名
os.rmdir(path) # 删除空目录
# os.path 模块
os.path.abspath(path)
os.path.dirname(path)
os.path.exists(path) # 文件存在返回 True
os.path.isfile(path)
os.path.islink(path)
os.path.ismount(path) # 挂载点
os.path.join(path1, path2)
os.path.split(path) # 路径分割为dirname和basename
# 异常
import sys
try:
f = open('1.txt')
except OSError:
print('...')
except ValueError:
print('...')
except:
print(sys.exc_info()[0])
raise
f.close()
# 定义异常
class MyError(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
self.repr(self.value)
try:
raise MyError(2 * 2):
except MyError as e:
print('...', e.value)
# OOP
# __init__(self) 构造方法，在类实例化时会自动调用,self代表类的实例，而非类
# python <= 3.6
class A:
def __init__(self, x, y):
self.x = x
self.y = y
def add(self):
return self.x + self.y
# python >= 3.7
from dataclass import dataclass
@dataclass
class A:
x: int
y: int
def add(self):
reutrn
self.x + self.y
# __str__
class people:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return ('This person's name is {}, and he is {}years old.'.format(self.name, self.age))
a = people('Mike', 18)
print(a) # This person's name is Mike, and he is 18 yeas old.
# 多继承
class people:
def __init__(self, n, a, w):
self.name = n
self.age = a
self.__weight = 2 # 两个下划线开头声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__weight
def speak(self):
print('My name is {}, and my age is {}.'.format(self.name, self.age))
class student(people):
def __init__(self, n, a, w, g):
people.__init__(self, n, a, w)
self.grade = g
def speak(self):
print('My name is {} and my grade is {}.'.format(self.name, self.grade))
class speaker():
def __inint__(self, n, t)
self.name = n
self.topic = t
def speak(self):
print('I'm {}, and my topic is {}.'.format(self.name, self.topic))
class sample(speaker, student): # 多重继承
def __init__(self, n, a, w, g, t):
student.__init__(self, n, a, w, g)
speaker.__init__(self, n, t)
test = sample('Tim'， 25， 80， 4， 'Python')
test.speak() # 默认调用的是在括号中排前面的父类的方法
>> > I'm Tim, and my topic is Python.
class Parent:
def hello:
print('hello, this is Dad.')
class Child:
def hello:
print('hello, this is son.')
c = Child()
c.hello() # hello, this is son.
super(Child, c).hello() # hello, this is Dad.
# glob模块提供了一个函数用于从目录通配符搜索中生成文件列表
import glob
glob.glob('*.py')
>> > ['primes.py', 'random.py', 'quote.py']
# re模块为高级字符串处理提供了正则表达式工具
# datetime模块为日期和时间处理同时提供了简单和复杂的方法
from datetime import date
now = data.today() # datetime.date(2018.12.2)
now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
>> > '12-02-03. 02 Dec 2018 is a Sunday on the 02 day of December.'
# 字符串前面添加一个 r，表示原始字符串
filepath = 'C:\user\desktop\'
# f 格式化字符串（python >= 3.6）
name = "allen"
print(f"He said his name is {name}.") # 相当于 .format()
a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
zipped = zip(a,b) # 打包为元组的列表 [(1, 4), (2, 5), (3, 6)]
zip(a,c) # 元素个数与最短的列表一致 [(1, 4), (2, 5), (3, 6)]
zip(*zipped) # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式[(1, 2, 3), (4, 5, 6)]numpy:
reshape(-1) / reshape(1, -1) / reshape(-1, 1) 区别：
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
