python

python的几种拷贝方式

通过直接赋值的方式

old_list = [1, 2, 3]
new_list = old_list
print(id(old_list), id(new_list))

old_list.append(6)
print(old_list, new_list)
print(id(old_list), id(new_list))

1530306843208 1530306843208
[1, 2, 3, 6] [1, 2, 3, 6]
1530306843208 1530306843208

深浅拷贝

import copy
a = [1, 2, 3, 4, ['a', 'b']]  #原始对象

b = a  #赋值，传对象的引用
c = copy.copy(a)  #对象拷贝，浅拷贝
d = copy.deepcopy(a)  #对象拷贝，深拷贝

a.append(5)  #修改对象a
a[4].append('c')  #修改对象a中的['a', 'b']数组对象

print 'a = ', a
print 'b = ', b
print 'c = ', c
print 'd = ', d

输出结果：
a =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
b =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
c =  [1, 2, 3, 4, ['a', 'b', 'c']]
d =  [1, 2, 3, 4, ['a', 'b']]

Python的is

is是对比地址,==是对比值

*args and **kwargs

当你不确定你的函数里将要传递多少参数时你可以用*args.例如,它可以传递任意数量的参数:

>>> def print_everything(*args):
        for count, thing in enumerate(args):
...         print '{0}. {1}'.format(count, thing)
···
>>> print_everything('apple', 'banana', 'cabbage')
0. apple
1. banana
2. cabbage

相似的,**kwargs允许你使用没有事先定义的参数名:

>>> def table_things(**kwargs):
...     for name, value in kwargs.items():
...         print '{0} = {1}'.format(name, value)
...
>>> table_things(apple = 'fruit', cabbage = 'vegetable')
cabbage = vegetable
apple = fruit

round函数

round() 方法返回浮点数x的四舍五入值。0.120保留三位只显示0.12

print "round(80.23456, 2) : ", round(80.23456, 2)
print "round(100.000056, 3) : ", round(100.000056, 3)
print "round(-100.000056, 3) : ", round(-100.000056, 3)

print(‘%.2f’ %(all/count))

列表添加元素

append
insert
extend

python数据类型

1、数字类型：

python的数字类型包括：

int（长整型）
float（浮点型）
complex（复数）
bool（布尔型）

数字数据类型用于存储数值，他们是不可改变的数据类型

2、字符串类型：
python的字符串或串(String)是由数字、字母、下划线组成的一串字符

字符串截取：s = a[i:j]，其中i,j可以不写，表示从位置i开始
字符串连接用‘+’号

字符串重复用’*‘号

3、列表类型：
python的列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套或者叫多维列表，可以用来表示多维数组）。列表用 [ ] 标识，是 python 最通用的复合数据类型

4、元组类型：
python的元组类似于list列表，元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表

元组的取值、截取、连接、重复与列表一样，

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则，对于空元组直接用小括号或者tuple()表示，对于1个元素的元组，则需要在元素后面添加逗号，

5、字典类型：
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型；列表是有序的对象集合，字典是无序的对象集合；字典用”{ }”标识；字典由索引(key)和它对应的值value组成

字典取值，字典当中的元素是通过键来存取的，而不是通过偏移存取

键(key)必须使用不可变类型（数字、字符串、元组）；在同一个字典中，键(key)必须是唯一的

6、集合类型：
python的集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员；基本功能是进行成员关系测试和删除重复元素；可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典

set()函数只接受一个参数，且改参数类型不为数字类型

正则

re.match(pattern, string, flags=0)
\w 匹配字母数字及下划线
\W 匹配非字母数字及下划线
matchObj = re.match( r’(.) are (.?) .*’, line, re.M|re.I)

mvc mvt

mvc一般指MVC框架。经典MVC模式中，M是指模型，V是视图，C则是控制器
T：templa
在MVC中

model是主要是封装对数据库层的访问，对数据库中的数据进行增删改查操作

views 是用于封装结果，生程页面展示html 内容

controller 是用于接收请求，处理业务逻辑，与前两者交互，返回结果

MVT中

m为mvc中的功能相同，负责和数据库交互，进行数据处理

v是和mvc的c的意识相同接收请求，进行业务处理，返回应答

t 是templa与mvc的v功能相同，负责封装构造要返回的html

emmmm

CREATE TABLE t_user (

id INT(11) NOT NULL AUTO_INCREMENT,

sex CHAR(2) NULL,

PRIMARY KEY (id),

CONSTRAINT sex CHECK (sex in(‘男’,’女’)));

python切片

>>> a = list(range(10))
 >>> a
 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 >>> a[:5]
 [0, 1, 2, 3, 4]
 >>> a[5:]
 [5, 6, 7, 8, 9]
 >>> a[2:8]
 [2, 3, 4, 5, 6, 7]
 >>> a[::2]
 [0, 2, 4, 6, 8]
 >>> a[::-1]
 [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

step为负数
当step为负数时，切片将其解释为从start出发以步长|step|逆序索引序列，此时，start和stop的截断依然遵循前述规则，但缺省发生一点变化，因为我们说过，在缺省的情况下，Python的行为是尽可能取最大区间，此时访问是逆序的，start应尽量取大，stop应尽量取小，才能保证区间最大，因此：

按照扩充索引范围的观点，start的缺省值是无穷大()，stop的缺省值是无穷小()

>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[5::-1]
[5, 4, 3, 2, 1, 0]
>>> a[:4:-2]
[9, 7, 5]
>>> a[::-1]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

日期api

dd=dd+datetime.timedelta(days=1)#日期不断增加1天

map

a = list(map(int, input().split()))
创建一个列表，使用 split() 函数进行分割
map() 函数根据提供的函数对指定序列做映射，就是转化为int型
split()返回分割后的字符串列表。

datetime

import datetime

start = datetime.date(2000, 1, 1)
end = datetime.date(2020, 10, 1)
days = datetime.timedelta(days=1)
ans = 0

while end >= start:
    if start.day == 1 or start.weekday() == 0: 
        ans += 2
    else:
        ans += 1
    start += days
print(ans)

datetime.date：表示日期的类，常用的属性有year, month, day
datetime.datetime：表示日期时间的类，常用的属性有hour, minute, second, microsecond
datetime.time：表示时间的类
datetime.timedelta：表示时间间隔，即两个时间点的间隔。在日期上做天days，小时hour，分钟，秒，毫秒，微妙的时间计算
datetime.tzinfo：时区的相关信息
date.weekday()：返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推；

data.isoweekday()：返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推；
date.year¶
在 MINYEAR 和 MAXYEAR 之间，包含边界。

date.month
1 至 12（含）

date.day
返回1到指定年月的天数间的数字。

import time
from datetime import date
today = date.today()
today
datetime.date(2007, 12, 5)
today == date.fromtimestamp(time.time())
True
my_birthday = date(today.year, 6, 24)
if my_birthday < today:
    my_birthday = my_birthday.replace(year=today.year + 1)
my_birthday
datetime.date(2008, 6, 24)
time_to_birthday = abs(my_birthday - today)
time_to_birthday.days

辗转相除法

def work(a,b):
    m=max(a,b)
    n=min(a,b)
    r=m%n
    while r!=0:
        m=n
        n=r
        r=m%n
    return n

排列组合

import itertools
# 请在此输入您的代码
# 表示相邻元素
dict = {'a': ['f', 'b'], 'b': ['a', 'c', 'g'], 'c': ['b', 'd', 'g'],
        'd': ['e', 'c'], 'e': ['d', 'f', 'g'], 'f': ['a', 'e', 'g'],
        'g': ['b', 'c', 'e', 'f']}
s = 'abcdefg'
ans = []
cnt = 0
# 先找出全排列 在去全排列里筛选
for i in range(1, 8):
    for x in itertools.combinations(s, i):
        ans.append("".join(x))
print(ans)

x的值为：
(‘a’,)
(‘b’,)
(‘c’,)
(‘d’,)
(‘e’,)
(‘f’,)
(‘g’,)
(‘a’, ‘b’)
(‘a’, ‘c’)
(‘a’, ‘d’)
(‘a’, ‘e’)
(‘a’, ‘f’)
(‘a’, ‘g’)
(‘b’, ‘c’)
(‘b’, ‘d’)
(‘b’, ‘e’)
(‘b’, ‘f’)
(‘b’, ‘g’)
(‘c’, ‘d’)
(‘c’, ‘e’)
(‘c’, ‘f’)
(‘c’, ‘g’)
(‘d’, ‘e’)
(‘d’, ‘f’)
(‘d’, ‘g’)
(‘e’, ‘f’)
(‘e’, ‘g’)
(‘f’, ‘g’)
(‘a’, ‘b’, ‘c’)
(‘a’, ‘b’, ‘d’)
(‘a’, ‘b’, ‘e’)
(‘a’, ‘b’, ‘f’)
(‘a’, ‘b’, ‘g’)
(‘a’, ‘c’, ‘d’)
(‘a’, ‘c’, ‘e’)
(‘a’, ‘c’, ‘f’)
(‘a’, ‘c’, ‘g’)
(‘a’, ‘d’, ‘e’)
(‘a’, ‘d’, ‘f’)
(‘a’, ‘d’, ‘g’)
(‘a’, ‘e’, ‘f’)
(‘a’, ‘e’, ‘g’)
(‘a’, ‘f’, ‘g’)
(‘b’, ‘c’, ‘d’)
(‘b’, ‘c’, ‘e’)
(‘b’, ‘c’, ‘f’)
(‘b’, ‘c’, ‘g’)
(‘b’, ‘d’, ‘e’)
(‘b’, ‘d’, ‘f’)
(‘b’, ‘d’, ‘g’)
(‘b’, ‘e’, ‘f’)
(‘b’, ‘e’, ‘g’)
(‘b’, ‘f’, ‘g’)
(‘c’, ‘d’, ‘e’)
(‘c’, ‘d’, ‘f’)
(‘c’, ‘d’, ‘g’)
(‘c’, ‘e’, ‘f’)
(‘c’, ‘e’, ‘g’)
(‘c’, ‘f’, ‘g’)
(‘d’, ‘e’, ‘f’)
(‘d’, ‘e’, ‘g’)
(‘d’, ‘f’, ‘g’)
(‘e’, ‘f’, ‘g’)
(‘a’, ‘b’, ‘c’, ‘d’)
(‘a’, ‘b’, ‘c’, ‘e’)
(‘a’, ‘b’, ‘c’, ‘f’)
(‘a’, ‘b’, ‘c’, ‘g’)
(‘a’, ‘b’, ‘d’, ‘e’)
(‘a’, ‘b’, ‘d’, ‘f’)
(‘a’, ‘b’, ‘d’, ‘g’)
(‘a’, ‘b’, ‘e’, ‘f’)
(‘a’, ‘b’, ‘e’, ‘g’)
(‘a’, ‘b’, ‘f’, ‘g’)
(‘a’, ‘c’, ‘d’, ‘e’)
(‘a’, ‘c’, ‘d’, ‘f’)
(‘a’, ‘c’, ‘d’, ‘g’)
(‘a’, ‘c’, ‘e’, ‘f’)
(‘a’, ‘c’, ‘e’, ‘g’)
(‘a’, ‘c’, ‘f’, ‘g’)
(‘a’, ‘d’, ‘e’, ‘f’)
(‘a’, ‘d’, ‘e’, ‘g’)
(‘a’, ‘d’, ‘f’, ‘g’)
(‘a’, ‘e’, ‘f’, ‘g’)
(‘b’, ‘c’, ‘d’, ‘e’)
(‘b’, ‘c’, ‘d’, ‘f’)
(‘b’, ‘c’, ‘d’, ‘g’)
(‘b’, ‘c’, ‘e’, ‘f’)
(‘b’, ‘c’, ‘e’, ‘g’)
(‘b’, ‘c’, ‘f’, ‘g’)
(‘b’, ‘d’, ‘e’, ‘f’)
(‘b’, ‘d’, ‘e’, ‘g’)
(‘b’, ‘d’, ‘f’, ‘g’)
(‘b’, ‘e’, ‘f’, ‘g’)
(‘c’, ‘d’, ‘e’, ‘f’)
(‘c’, ‘d’, ‘e’, ‘g’)
(‘c’, ‘d’, ‘f’, ‘g’)
(‘c’, ‘e’, ‘f’, ‘g’)
(‘d’, ‘e’, ‘f’, ‘g’)
(‘a’, ‘b’, ‘c’, ‘d’, ‘e’)
(‘a’, ‘b’, ‘c’, ‘d’, ‘f’)
(‘a’, ‘b’, ‘c’, ‘d’, ‘g’)
(‘a’, ‘b’, ‘c’, ‘e’, ‘f’)
(‘a’, ‘b’, ‘c’, ‘e’, ‘g’)
(‘a’, ‘b’, ‘c’, ‘f’, ‘g’)
(‘a’, ‘b’, ‘d’, ‘e’, ‘f’)
(‘a’, ‘b’, ‘d’, ‘e’, ‘g’)
(‘a’, ‘b’, ‘d’, ‘f’, ‘g’)
(‘a’, ‘b’, ‘e’, ‘f’, ‘g’)
(‘a’, ‘c’, ‘d’, ‘e’, ‘f’)
所以需要通过join函数处理
结果：[‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘ab’, ‘ac’, ‘ad’, ‘ae’, ‘af’, ‘ag’, ‘bc’, ‘bd’, ‘be’, ‘bf’, ‘bg’, ‘cd’, ‘ce’, ‘cf’, ‘cg’, ‘de’, ‘df’, ‘dg’, ‘ef’, ‘eg’, ‘fg’, ‘abc’, ‘abd’, ‘abe’, ‘abf’, ‘abg’, ‘acd’, ‘ace’, ‘acf’, ‘acg’, ‘ade’, ‘adf’, ‘adg’, ‘aef’, ‘aeg’, ‘afg’, ‘bcd’, ‘bce’, ‘bcf’, ‘bcg’, ‘bde’, ‘bdf’, ‘bdg’, ‘bef’, ‘beg’, ‘bfg’, ‘cde’, ‘cdf’, ‘cdg’, ‘cef’, ‘ceg’, ‘cfg’, ‘def’, ‘deg’, ‘dfg’, ‘efg’, ‘abcd’, ‘abce’, ‘abcf’, ‘abcg’, ‘abde’, ‘abdf’, ‘abdg’, ‘abef’, ‘abeg’, ‘abfg’, ‘acde’, ‘acdf’, ‘acdg’, ‘acef’, ‘aceg’, ‘acfg’, ‘adef’, ‘adeg’, ‘adfg’, ‘aefg’, ‘bcde’, ‘bcdf’, ‘bcdg’, ‘bcef’, ‘bceg’, ‘bcfg’, ‘bdef’, ‘bdeg’, ‘bdfg’, ‘befg’, ‘cdef’, ‘cdeg’, ‘cdfg’, ‘cefg’, ‘defg’, ‘abcde’, ‘abcdf’, ‘abcdg’, ‘abcef’, ‘abceg’, ‘abcfg’, ‘abdef’, ‘abdeg’, ‘abdfg’, ‘abefg’, ‘acdef’, ‘acdeg’, ‘acdfg’, ‘acefg’, ‘adefg’, ‘bcdef’, ‘bcdeg’, ‘bcdfg’, ‘bcefg’, ‘bdefg’, ‘cdefg’, ‘abcdef’, ‘abcdeg’, ‘abcdfg’, ‘abcefg’, ‘abdefg’, ‘acdefg’, ‘bcdefg’, ‘abcdefg’]

permutations是A，combination是C

 import itertools

 list(itertools.combinations('abc', 2))
[('a', 'b'), ('a', 'c'), ('b', 'c')]
 list(itertools.permutations('abc',2))
[('a', 'b'), ('a', 'c'), ('b', 'a'), ('b', 'c'), ('c', 'a'), ('c', 'b')]

蓝桥杯读入二维数组

n,m=map(int,input().split())#n为行，m为列
p=[list(map(int,input().split())) for i in range(n)]#将数据记录在二维列表里

二维数组定义

查阅资料后发现list的浅拷贝问题，二维列表里面保存的是一维列表的地址，我这样赋值是把第一个[3]*3也就是[3,3,3]的地址复制了四遍，这个二位列表看似有了四个一维的[3,3,3]，但是其实它们在内存里都是指向一个对象，所以之后修改任意一行的其中元素，其他行的对应位置元素也会被改变。真服了，困扰老子一天
在 Python 中定义二维数组的正确方式应该是使用 for 循环：

dp = [[0] * N for _ in range(M)]

不应该使用：

dp = [[0] * N ] * M

一维数组可以用[ 0 ] ∗ N [0] * N[0]∗N 这种声明方式，但是二维数组不能用上面的声明方式，这会导致 dp 中的每行的列表是同一个 id，所以对其中一行的操作都会表现为每一行的操作。

读取以空格分隔的一行整数

a,b,c = map(int, input().split()) #或者
a,b,c = [int(i) for i in input().split()]

num_list = list(map(int, input().split())) #或者
num_list = [int(i) for i in input().split()]

或者

n = input()
list = []
for i in n.split():
    list.append(int(i))
 
for i in list:
    print(i)

n = input()
list = [int(j) for j in n.split()]
print(list)
or
list= [int(num) for num in input().split()]
print(list)
## print
```python
print("%02d:%02d:%02d" % (h, m, s))

sort and sorted

sorted() 是函数，其返回的是一个新的列表

x=sorted(cars)

print(x) cars列表里的内容没有改变

cars.sort() 原列表直接进行方法调用，所以原列表进行了排序，不可逆

Linux

Linux常见命令：

cp

cp [options] source dest

cat

cat（英文全拼：concatenate）命令用于连接文件并打印到标准输出设备上。

tar

tar -xzvf test.tar.gz 解压文件

ls

ls（英文全拼： list directory contents）命令用于显示指定工作目录下之内容（列出目前工作目录所含之文件及子目录)。

grep

Linux grep 命令用于查找文件里符合条件的字符串。

grep 指令用于查找内容包含指定的范本样式的文件，如果发现某文件的内容符合所指定的范本样式，预设 grep 指令会把含有范本样式的那一列显示出来。若不指定任何文件名称，或是所给予的文件名为 -，则 grep 指令会从标准输入设备读取数据。

vscode快捷键

ctrl k + ctrl u快速取消注释

python-tips