Some Basic Usage of Python

基本语法

代码注释

# 第一个注释

'''
注释
注释
'''

"""
注释
注释
"""

多行语句

total = item_one + \
        item_two + \
        item_three

在[]，{}，()中的多行语句不需要使用反斜杠。

变量

Python中变量不需要声明，使用前必须赋值，赋值后变量才会被创建。

局部变量

APPLY = 100 # 全局变量
def fun():
    a = 10  # 局部变量
    return a+100

print(APPLE)    # 100
print(a)    # 报错, 不能拿到一个局部变量的值

全局变量

APPLY = 100 # 全局变量
a = None  # 全局变量
def fun():
    global a    # 使用之前在全局里定义的 a
    a = 20      # 现在的 a 是全局变量了
    return a+100

print(APPLE)    # 100
print('a past:', a)  # None
fun()
print('a now:', a)   # 20

数据类型

Number 数字
String 字符串
Tuple 元组
List 列表
Dictionary 字典
Set 集合

不可变数据：Number，String，Tuple；可变数据：List，Dictionary，Set。

Number类型（不可变）

int：只有一种整数类型，为长整型
bool
float：1.23,3E-2
complex：1+2j

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

>>> isinstance(a, int)
True

字符串（不可变）

python中单引号和双引号使用完全相同。
三引号指定一个多行字符串。
转义符\，r可以阻止转义，如：r"this is a line with \n" 则\n会显示，并不是换行。
级联字符串：”this “ “is “ “string”会被自动转换为this is string。
字符串可以用 + 运算符连接在一起，用 * 运算符重复。
Python中的字符串不能改变。

str='chenshiyu'
print(str)                 # 输出字符串
print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str[0])              # 输出字符串第一个字符
print(str[2:5])            # 输出从第三个开始到第五个的字符
print(str[2:])             # 输出从第三个开始的后的所有字符
print(str * 2)             # 输出字符串两次
print(str + '你好')        # 连接字符串 
print('------------------------------') 
print('hello\nrunoob')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

tuple（不可变）

a_tuple = (12, 3, 5, 15 , 6)
another_tuple = 12, 3, 5, 15 , 6

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')

print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组

list（可变）

a = [12, 3, 67, 7, 82]
a.append(0)  # 在a的最后面追加一个0
a.insert(1,0) # 在位置1处添加0
a[1] = 9   # 改变元素值
a.remove(12) # 删除列表中第一个出现的值为12的项
print(a[0])  # 显示列表a的第0位的值
print(a[-1]) # 显示列表a的最末位的值
print(a[0:3]) # 显示列表a的从第0位 到 第2位(第3位之前) 的所有项的值
print(a[5:])  # 显示列表a的第5位及以后的所有项的值
print(a[-3:]) # 显示列表a的倒数第3位及以后的所有项的值
print(a.index(7)) # 显示列表a中第一次出现的值为7的项的索引
print(a.count(3)) # 统计列表中3出现的次数
a.sort() # 默认从小到大排序
a.sort(reverse=True) # 从大到小排序

multi_dim_a = [[1,2,3],
			   [2,3,4],
			   [3,4,5]] # 三行三列
print(multi_dim_a[0][1])

dict（可变）

字典是无序的key:value对象集合，列表是有序的。

d1 = {'apple':1, 'pear':2, 'orange':3}
d2 = {1:'a', 2:'b', 3:'c'}
d3 = {1:'a', 'b':2, 'c':3}

dict = {}
dict['one'] = "1"
dict[2]     = "2"
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

>>>dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Taobao': 3, 'Runoob': 1, 'Google': 2}
 
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
 
>>> dict(Runoob=1, Google=2, Taobao=3)
{'Runoob': 1, 'Google': 2, 'Taobao': 3}

set（可变）

parame = {value01,value02,...}
set(value)
set()  # 创建空集合必须用set()

student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student)   # 输出集合，重复的元素被自动去掉
# 成员测试
if 'Rose' in student :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素

运算符

a**b：a的b次方
//：整除
and,or,not：布尔“与或非”
in，not in：如果x在y序列中返回True

函数定义

def function_name(parameters):
    expressions
    ...

例如：

def func(a, b):
    c = a+b
    print('the c is ', c)

调用func时，不指定参数func()将会出错；func(1,2); func(a=1,b=2); func(b=2,a=1)均正确。

默认参数

默认参数即已赋值的备选参数，在函数调用时可以不明确给出，如：

def function_name(para_1,...,para_n=defau_n,..., para_m=defau_m):
    expressions

注：所有的默认参数都不能出现在非默认参数的前面。

可变参数和关键字参数

def total(a=5, *numbers, **phonebook):
    print('a', a)

    for single_item in numbers:
        print('single_item', single_item)

    for first_part, second_part in phonebook.items():
        print(first_part, second_part)

print(total(10,1,2,3,Jack=1123,John=2231,Inge=1560))

输出：

a 10
single_item 1
single_item 2
single_item 3
Jack 1123
John 2231
Inge 1560
None

可变参数*param：传入的参数可以是变化的，个数可变，1个，2个或任意个，将这些参数封装成一个list或者tuple传入。

不使用可变参数时：

def calc(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

调用命令：calc([1,2,3])或calc((1,2,3))

使用可变参数时：

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

调用命令：calc(1,2,3)或calc()（无参数时输出为0）

已有list或者tuple时，使用可变参数方法：

nums=[1,2,3]
calc(nums[0],numsp[1],nums[2])  # or calc(*nums)  or  calc(*[1,2,3])

注：可变参数在函数定义时不能出现在特定参数和默认参数前面，否则会吞噬这些参数。

关键字参数**param：所有的关键字参数都将被汇集成一个名为param的dict。

通过可变参数和关键字参数，任何函数都可以用func(*args, **kw)表达。

运算函数

abs(x)：绝对值
fabs(x)：绝对值float型，math.fabs(-10)=10.0
ceil(x)：返回x的上入整数，math.ceil(4.1)=5
floor(x)：返回x的下舍整数，math.floor(4.9)=4
sqrt(x)：平方根
exp(x)：e的x次幂，math.exp(1)=2.718
log(x)：math.log(math.e)=1.0
log10(x)：math.log10(100)=2.0
pow(x,y)：x**y
round(x[,n])：返回x的四舍五入值，n表示舍入到小数点后的位数
random.choice(range(10))：从0到9中随机选一个整数
random.randrange([start,]stop[,step])：从指定范围中，获取一个随机数，缺省值为1
random.random()：随机生成一个实数，在[0,1)范围内
random.seed([x])：改变随机数生成器的种子seed
random.shuffle(list)：将序列的所有元素随机排序
random.uniform(x,y)：随机生成一个实数，在[x,y]范围内
math.degrees(x)：将弧度转换为角度，degrees(math.pi/2)=90.0
math.radians(x)：将角度转换为弧度

随机采样

import numpy as np
np.random.choice(a, size=None, replace=True, p=None)

a: 一位数组ndarray, list, tuple，从中随机抽取元素组成大小为size的数组.
replace: True表示可以取相同数字，False表示不可以取相同数字.
p: 与a对应，表示取a中元素的概率，默认为选取每个元素的概率相同.

zip

接受任意个序列作为参数，合并后返回一个列表。

a=[1,2,3]
b=[4,5,6]
ab=zip(a,b)
print(list(ab))  #需要加list来可视化这个功能

[(1, 4), (2, 5), (3, 6)]

for i,j in zip(a,b):
     print(i/2,j*2)

0.5 8
1.0 10
1.5 12

lambda

定义一个简单的函数，实现简化代码的功能。

fun = lambda x,y:x+y
x=int(input('x='))    #这里要定义int整数，否则会默认为字符串
y=int(input('y='))
print(fun(x,y))

map

根据提供的函数对指定序列做映射。

map(function, iterable, ...)

>>>def square(x) :            # 计算平方数
...     return x ** 2
... 
>>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
 
# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]

类定义

class Calculator:       #首字母要大写，冒号不能缺
    name='Good Calculator'  #该行为class的属性
    price=18
    def add(self,x,y):
        print(self.name)
        result = x + y
        print(result)
    def minus(self,x,y):
        result=x-y
        print(result)
    def times(self,x,y):
        print(x*y)
    def divide(self,x,y):
        print(x/y)

调用方法：

cal = Calculator()   #调用时要加‘()’，否则调用函数时会出错
cal.name
cal.add(10,20)

init功能

__init__：初始化class的变量。

class people:
    def __init__(self, n, a, w):   # 将对象的参数引入类进行赋值
        self.name = n
        self.age = a
        self.__weight = w    # 内部变量，类之外无法调用
    def speak(self):
        print('{} say: I am {} years old, weight is {}' .format(self.name, self.age,self.__weight))

p = people('chenshiyu',26,73)
p.speak()
print(p.name,p.age)

子类

class student(people):
    def __init__(self, n, a, w, g):
        people.__init__(self, n, a, w)
        self.grade = g
        self.__weight = w
    def speak(self):
        print('{} say: I am {} years old, weight is {}, and I am a student in {}.' .format(self.name,self.age,self.__weight,self.grade))

s = student('csy', 26, 73, 'phd')
s.speak()

读写文件

\n：换行命令
\t：tab对齐

打开文件并写入内容

text = 'chenshiyu'
my_file = open('my file.txt','w')   #用法: open('文件名','形式'), 其中形式有'w':write(若文件不存在，会自动新建);'r':read.
my_file.write(text)               #该语句会写入先前定义好的 text
my_file.close()                   #关闭文件

增加文件内容

append_text = '\nThis is appended file.'  # 为这行文字提前空行 "\n"
my_file = open('my file.txt','a')   # 'a'=append 以增加内容的形式打开
my_file.write(append_text)
my_file.close()

读取文件内容

file = open('my file.txt','r') 
content=file.read()  
print(content)

content=file.readline()  # 读取第一行
print(content)

second_read_time=file.readline()  # 读取第二行
print(second_read_time)

content=file.readlines() # python_list 形式输出
print(content)
for item in content:
    print(item)

import模块

import numpy as np
import matplotlib.pyplot as plt

import time
print(time.localtime())  # 这样就可以输出当地时间了

from time import time, localtime  # 只import想要的功能
print(localtime())

from time import *  # 输入模块所有功能
print(localtime())

调用自己编写的模块：保存文件名为func.py，则import func

dir(模块名称)函数：可以找到模块内定义的所有名称，以字符串列表形式返回。

包

包是一种管理Python模块命名空间的形式，采用“点模块名称”。

sound/                          顶层包
      __init__.py               初始化 sound 包
      formats/                  文件格式转换子包
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  声音效果子包
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  filters 子包
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...

目录中只有包含__init__.py的文件夹才会被认为是一个包。

__init__.py的写法：

放一个名称为__init__.py的空文件
包含一些初始化代码或者__all__变量赋值，此时使用from package import *时，就会把__all__列表变量中的所有名字作为包内容导入，如：__all__ = ["echo", "surround", "reverse"]

脚本自调用

if __name__ == '__main__':
    #code_here

运行该脚本时，if语句为True,内部代码将会执行；如果是外部调用该脚本，则该段代码不执行。

yield用法¹

def fun():
    print("starting...")
    while True:
        res = yield 4
        print("res:",res)
g = fun()
print(next(g))
print("*"*20)
print(next(g))

# output
starting... # 第一次调用next
4
********************
res: None # 第二次调用next，接上次断点继续执行
4

函数形参中的`*`与`**`用法

`fun(*args)`

可以传入任意个参数，这些参数都被放到tuple元组中赋值给形参args

`fun(**kwargs)`

以键值对-字典的方式向函数传参，没有位置和参数数量的限制

同时使用*args与**kwargs时，*args要放在前面。

References

https://blog.csdn.net/mieleizhi0522/article/details/82142856/ ↩