Python 基本语法 / 内置函数速查

 

# 交换两个数据
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)  区别：