Python——基础篇

# pip/python -V来查看当前版本
# which pip/python来查看命令所在的路径，一般安装路径为/usr/lib或/usr/local/lib下
# 更改软链接前需要删除之前建立好的链接
mv /usr/bin/python /usr/bin/python.bak
ln -s /usr/bin/python3.6 /usr/bin/python

# 之后需要根据提示修改例如yum脚本第一行#!/usr/bin/python为python2

# 设置windows下的代理
set http_proxy={proxyid:port}
set https_proxy={proxyid:port}

# 旧版本依赖多，不能清晰的删除，此时应该忽略旧版本升级
pip install --ignore-installed {kit-name}

# 查看pip安装路径，可以再输入一次pip install，即可根据提示“already satisfied”后的路径找到

# 显示ConnectTimeoutError的WARRING时，暂时更改pip镜像源
pip install -i http://mirrors.aliyun.com/pypi/simple/ {package-name}

# 提示not a trusted or secure host导致无法找到镜像
# 源地址：http://pypi.mirrors.ustc.edu.cn/simple/；http://mirrors.aliyun.com/pypi/simple/
pip install {package-name} -i http://pypi.douban.com/simple --trusted-host pypi.douban.com

python2 -m pip install {package-name}
python3 -m pip install {package-name}

py -2 {file-name}.py
py -3 {file-name}.py

// 对象（变量或字面值）的类型
type()

// 运算符
+     加法
-     减法
*     乘法
/     浮点数除法
//    整数除法
%     模（求余）
**    幂
divmod()  返回(商,余数)

// 基数
0b或0B代表二进制
0o或0O代表八进制
0x或0X代表十六进制

// 类型转换
int()可以接受浮点数或由数字组成的字符串，但是无法接受包含小数点或指数的字符串
>>> int(98.6)
98
>>> int('-23')
-23

// 字符串
''或""中创建字符串
交互式解释器输出的字符串为单引号包裹。双引号中可以包含单引号。
三引号用于创建多行字符串，每行的换行符及行首末的空格会保留，例如
>>> poem = '''There was a Young Lady of Norway,
... Who casually sat in a door way;
... When the door squeezed her flat,
... She exclaimed, "What of that?"
... This courageous Young Lady of Norway.'''
（1）但当我们调用print() 进行打印时，Python 会在各个参数之间自动添加空格并在结尾添加换行符；
（2）可以使用字”符串*数字“来复制字符串；
（3）偏移量[]可以使用0，-1表示最左边和最右边字符；
（4）字符串不可改变。

[start:end:step]

# 整个字符串，等价于[:]
[0:-1]
# 提取最后三个字符
[-3:]
# 反向提取字符串，等价于[::-1]
[-1::-1]

# 结果为list，如果待分割的字符串中包含连续的分隔符，那么在返回的列表中会出现空串元素。
string.split(',')

# 首先指定粘合用的字符串，然后再指定需要合并的列表
string.join(_list)

# 首字母大写
capitalize()

# 所有单词开头字母大写
title()

# 全大写
upper()

# 全小写
lower()

# 所有字符大小写互换
swapcase()

# 字符串对齐操作：center(30)、ljust(30)、rjust(30)

# 删除指定字符
string.strip('.')

# 参数：需要被替换的子串，用于替换的新子串，以及需要替换多少处（默认只替换第一次）。可借助正则表达式。
setup.replace('a ', 'a famous ', 100)

# 1.添加元素到最后
.append()

# 2.使用extend()或+=合并列表
# append()会将list插入到一个元素中，使用+=可以避免

# 3.del为python语句，不能通过方法形式调用
del _list[offset]

# 4.删除指定元素
_list.remove('value')

# 5.使用pop()获取并删除指定位置的元素，默认为-1
_list.pop(number)

# 6.查询具有特定值的元素位置
_list.index('value')

# 7.判断值是否存在
'value' in _list

# 8.记录特定值出现的次数
_list.count('value')

# 9.重新排列元素
# 列表方法 sort() 会对原列表进行排序，改变原列表内容;
# 通用函数 sorted() 则会返回排好序的列表副本，原列表内容不变。
sorted_list = sorted(_list)
_list.sort()
_list.sort(reverse=True) # 默认升序排列，此处改为降序排列

# 10.获取长度
len(_list)

# 11.复制，无关联。列表 copy() 函数、list() 转换函数、列表分片 [:]
b = a.copy()
c = list(a)
d = a[:]

# FIFO，队列
append() + pop()

# FILO，栈
append() + pop(0)

# 1.创建，只有一个末尾也必须加','（定义元组），如果元组数大于1，最后的','可以省略
one_tuple = 'Groucho',  # 或('Groucho')
many_tuple = 'Groucho', 'Chico', 'Harpo' # 或('Groucho', 'Chico', 'Harpo')

_list = ['Groucho', 'Chico', 'Harpo'] 
many_tuple = tuple(_list)

# 2.元组解包
a, b, c = many_tuple

tuple1 = 'abc','def'
tuple2 = '123','456'
tuple3 = 'a1','b2'
tuple1, tuple2, tuple3 = tuple2, tuple3, tuple1 # 利用元组交换值

# 1.dict()，将包含双值子序列的序列转换成字典
lol = [['a', 'b'], ['c', 'd'], ['e', 'f']]. # 或los = ['ab', 'cd', 'ef']
dict(lol)

lol['new_key'] = 'new_value'

# 2.update()，将一个字典的键值对复制到另一个字典中去
dict1.update(dict2)

# 3.删除元素
del dict1['value']
dict1.clear()

# 4.判断某一个键是否存在于一个字典中
'key' in dict1  # 返回true or false

# 5.获取值
dict1.get('key')  # 不存在返回None
dict1['key']  # 不存在会报错

dict1.keys()  # 获取所有键，返回一个列表（p2）或dict_keys()键的迭代形式（p3）
dict1.values()
dict1.items()

# 6.复制，=或copy()

# 1.去重set()，判断是否在内in

# 2.集合运算符
# 交集运算符&，结果是一个集合
# 或者通过集合函数 a.intersection(b)

# 并集：｜、union()

# 差集：-、difference() 

# 异或集（仅在两个集合中出现一次，即不同的）：^、symmetric_difference() 

# 子集：<=、issubset() 

# 超集：>=、issuperset()（真超集：>）

# not替代!
if {condition}:
	{expression}
elif:
	{expression}
else:
	{expression}

# break, continue
while {condition}:
	{expression}
else {condition}:
	{expression}

# 简洁编码
# 列表(例如 rabbits)、字符串、元组、字典、集合等都是 Python 中可迭代的对象。
strs = 'abc', 'def', 'ghi'  # 也可以是'cat'或dict1.items()
for str in strs: 
    print(str)
else {condition}:
	{expression}

for day, fruit, drink, dessert in zip(days, fruits, drinks, desserts):
	print(day, ": drink", drink, "- eat", fruit, "- enjoy", dessert)

for x in range(2, -1, -1): 
	print(x)
list( range(2, -1, -1) )  # 返回的是可迭代的对象

# method 1
number_list = [str(number) for number in range(1,6)] 

# method 2
cells = [(row, col) for row in rows for col in cols] 

# method 3
vec = [[1,2,3],[4,5,6],[7,8,9]]
result = {y for x in vec for y in x}  # 返回{1,2,3,4,5,6,7,8,9}

# 如果函数不显式调用 return 函数，那么会默认返回 None。
# 可以在def时指定默认参数值
def {function}():
	paas  # pass表明函数没有做任何事情

# 区别None和False
def is_none(thing): 
	if thing is None:  # is操作符
		print("It's None") 
	elif thing:
		print("It's True") 
	else:
		print("It's False")

# 参数另一种写法，避免混淆位置参数
menu(entree='beef', dessert='bagel', wine='bordeaux')

# 1.星号将一组可变数量的位置参数集合成参数值的元组（位置参数收集）
# 2.使用两个星号可以将参数收集到一个字典中，参数的名字是字典的键，对应参数的值是字典的值（关键字参数收集）
# 如果你的 函数同时有限定的位置参数，那么 *args 会收集剩下的参数
def print_more(required1, required2, *args):


# 文档字符串
def print_if_true(thing, check): 
	'''
	Prints the first argument if a second argument is true. 
	The operation is:
		1. Check whether the *second* argument is true.
		2. If it is, print the *first* argument. 
	'''
	if check:
    	print(thing)
# 打印输出一个函数的文档字符串
help(print_if_true)
# 只打印文档字符串
print(print_if_true.__doc__)


# 闭包（内部函数，一个被动态创建的可以记录 外部变量的函数。）
# 由另一个函数动态生成的函数，并且可以改变和存储函数外创建的变量的值。

# 匿名函数:lambda()函数

>>> def document_it(func):
... 	def new_function(*args, **kwargs):
... 		print('Running function:', func.__name__)
... 		print('Positional arguments:', args)
... 		print('Keyword arguments:', kwargs)
... 		result = func(*args, **kwargs)
... 		print('Result:', result)
... 		return result
... 	return new_function

short_list = [1, 2, 3] >>> position = 5
try:
	short_list[position] 
except:
		print('Need a position between 0 and', len(short_list)-1, ' but got', position)


try:
	position = int(value) print(short_list[position])
except IndexError as err: 
	print('Bad index:', position)
except Exception as other: 
	print('Something else broke:', other)


class UppercaseException(Exception):
	pass

words = ['eeenie', 'meenie', 'miny', 'MO'] >>> for word in words:
	if word.isupper():
		raise UppercaseException(word)