python学习笔记

文章目录

• 前言
• 一、python基础语法
• • 1.输入输出
  • 2.语句
  • 3.数据类型
  • • 3.1 数字，字符串
    • 3.2 列表(list)
    • 3.3 元组
    • 3.4 字典
    • 3.5 集合
  • 4.函数
  • • 4.1 可变参数与关键字参数
    • 4.2 命名关键字参数
    • 4.3 匿名函数
    • 4.4 python内置函数
  • 5.切片
• 二、数据分析
• • 1.matpltlib
  • • 1.1 折线图
    • 1.2 散点图
    • 1.3 条形图
    • 1.4 直方图
  • 2.numpy
  • 3.pandas
• 三、数学建模
• 总结

---

前言

python数学建模个人学习笔记

一、python基础语法 1.输入输出

a = float(input("请输入单价："))
b = float(input("请输入数量："))
c = int(input("请输入学号："))
d = float(input("请输入一个小数："))
print("学号为：%06d" % c)
print("数据比例为：%.02f%%" % (d*100))
print("单价：%.02f,数量：%.02f,总价：%.02f" % (a, b, a * b))

'''
在Python中，split（）函数用于将多个输入作为列表数据类型。如果需要int、char或string类型的数据，则需要应用Python.In解决方法，我用同样的方法。在
n=int(raw_input())
for i in range(0,n):
     s=str(raw_input())
     St,Eng,Mat,Sci=raw_input().split()
     Eng=float(Eng)
     Mat=int(Mat)
     Sci=int(Sci)
     print St,s
     print Eng,Mat,Sci
'''

2.语句

例子：dijkstra python实现

n, m = map(int, input().split())
N = float("inf")
g = [[N] * (n + 1) for _ in range(n + 1)]  # 由于是密集图，m>>n，因此用邻接矩阵来存储，g[x][y]表示x指向y的距离
d = [N] * (n + 1)  # 存储每个点距离起点的距离，初始化为距离最大，d[1]=0
st = [False] * (n + 1)  # 判断某一点的最短距离是否已经确定，False表示未确定，True表示确定


def dijkstra():
    d[1] = 0
    for i in range(1, n + 1):  # 因为要确定n个点的最短路，因此要循环n次
        t = -1
        for j in range(1, n + 1):  # 每次找到还未确定最短路的点中距离起点最短的点t
            if not st[j] and (t == -1 or d[t] > d[j]):
                t = j
        st[t] = True
        for j in range(1, n + 1):  # 用t来更新t所指向的点的距离
            d[j] = min(d[j], d[t] + g[t][j])
    if d[n] >= N:
        return -1
    else:
        return d[n]


for _ in range(m):
    x, y, z = map(int, input().split())
    g[x][y] = min(g[x][y], z)  # 当出现重边时，只需取两个距离中的最小值
print(dijkstra())

3.数据类型 3.1 数字，字符串

字符串类型：
比较字符ASCII码值的大小：空格<数字<大写字母<小写字母
Unicode变字符：chr(u) ；字符变Unicode：ord(x)
format（）方法的格式控制：
（1）槽{序号}的使用
（2）{参数序号：格式控制标记}，格式控制标记包括：填充、对齐（分别用<、>、^表示左、右和居中对齐）、宽度、精度、类型（b=二进制，c=Unicode,d=十进制，o=八进制，xX=十六进制）。
字符串的类型判断：
str.isdigit()是否全为数字（0-9）；str.isalpha()是否全为字母；str.isal num()是否全为数字或字母；str.isspace()是否是空白（空格、制表符、换行符等）；str.isprintable()是否可打印（空格和没有东西是可以被打印的）；str.isidentifier()是否满足标识符定义规则（字母或下划线开头，只含数字、字母和下划线）
大小写转换：str.capitaiize()：转换为首字母大写，其余小写；str.title()各单词首字母大写。
对齐：居中str.center(长度，填充物) ；左对齐：ljust ；右对齐：rjust。
填充：str.zfill(长度)相当于右对齐，前方补0。如果str前有正负号，则正负号也算长度，在正负号之后填充。
移除：左右两边：str.strip(字符chars) ； 左边：str.lstrip() ；右边;rstrip（）
字符串的查找：find和index
str.find(s):从左至右查找str中是否含s,有则返回第一次出现s的索引位置，否则返回-1
str.index（x）：从左至右查找是否含有x，有则返回第一次出现的索引位置，没有则抛出ValueError
str.rfind()和str.rindex()就是从右至左查找。
字符串的替换：S.replace(old,new,count)。将S中的old替换为new，如果给定count，则只替换前count个old子串。
拆分/分割：
S.split(分隔符sep,分割次数maxsplit), maxsplit = -1或不指定时，会从左向右搜索完整个字符串。S.rsplit()是从右往左。生成列表。
S.partition(sep)，S.rpartition(sep)(从右往左搜索)。搜索S中的子串sep，并从第一个sep处分割，返回一个包含三个元素的元组 -->（sep左边的部分，sep，sep右边的部分）。如果搜索不到sep，则返回中有两个元素为空，partition是后两个元素为空，rpartition是前两个为空。
连接组合：S.join（字符串对象）。 当对象为字符串字典时，结果是键的连接。

a = complex(1, 2)  # 复数，或定义为a = 1 + 2j
print(type(a))  # 查看a的数据类型
b = 2 ** 128
c = True
d = 10.5
e = 10
str1 = "Hello "
str2 = "World"
print(b)
print(a)
print(c + d + e)  # 数字型变量可以相加，数字型和字符型之间不能相加
print(str1 + str2)
print(str2 * 10)

3.2 列表(list)

类似于stl中的链表(list)
列表list是可变对象，则对其增删改查不会改变其的id。除了list.copy().
方法：
（1）添加：
list.appand(x)：将元素x添加到列表的尾部；
list.extend(L)：将列表L中所有元素添加到列表的尾部；
list.insert(index,x)：在列表指定位置index处添加元素x；
（2）删除：
list.remove(x)：删除列表中首次出现的元素x；
list.pop(kediedai[index])：删除并返回指定位置的元素（可以理解为挖取出），list为空就抛IndexError异常；
list.clear()：删除列表中所有元素，但保留列表对象。
（3）排序：
list.reverse()：倒序；
list.sort()：排序（正或倒）；
（4）其他：
list.index(x)：返回值为x首次出现的下标；
list.count(x)：返回x的出现总次数；
list.copy() ：返回列表对象的浅拷贝。很厉害！！它可以改变列表的ID！
浅拷贝——只拷贝一层。如果拷贝对象只有一层，那么同b = a[:]，两个变量相互独立的。但如果拷贝对象只有一层，就会有影响，会跟着改变。

list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
 
print(list)              # 输出完整列表
print (list[0])            # 输出列表的第一个元素
print (list[-2])           # 输出倒数第二个元素
print (list[1:3])          # 输出第二个至第三个元素 
print (list[2:])           # 输出从第三个开始至列表末尾的所有元素
print (tinylist * 2)       # 输出列表两次
print (list + tinylist)    # 打印组合的列表

3.3 元组

列表允许更新，元组不允许更新的

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000    # 元组中是非法应用
list[2] = 1000     # 列表中是合法应用

3.4 字典

类似stl中的map
{建（key）：值（value）}。键不能重复，且是不可变对象。值可变。元素没有顺序。
创建一个空字典：dict（） ；创建字典：dict(‘a’=1,‘b’=2)/dict(‘a’:1,‘b’:2)/dict((‘a’,1),(‘b’,2))
查找值：Dict[key] ；修改键值：dict[key] = new_value ；增添新键值：dict[new_key] = new_value .
D.keys()：返回所有键的列表,如dict_keys([‘a’, ‘b’, ‘c’])；
D.values()：返回所有值的列表,如dict_values([1, 2, 3])；
D.items()：返回所有的键值对的列表,如dict_items([(‘a’, 1), (‘b’, 2), (‘c’, 3)])；
D.get(key,v)：键存在则返回相应值，否则返回None（自定义了v时，返回v的内容）;
D.pop(key.value)：键存在则返回相应值，同时删除键值对，否则返回None；
D.popitem()：随机取出一个键值对，以元组（key，value）形式返回；
D.setdefault(k,v)：如果键k存在，返回对应值，否则添加项目k = v,v默认为None；
D.update(dict)：更新或添加键值对；
D.clear()：删除所有的键值对；
del.D[key]：删除key对应的键值对。如果key不存在，则抛出KeyError。

dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
 
tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
 
 
print(dict['one'])        # 输出键为'one' 的值
print(dict[2])      # 输出键为 2 的值
print(tinydict)    # 输出完整的字典
print(tinydict.keys())  # 输出所有键
print(tinydict.values())# 输出所有值
print(dict.keys())  # 输出所有键
print(dict.values())# 输出所有值

3.5 集合

类似stl中的set
集合中的元素没有顺序，且不重复。集合set是可变的，用大括号表示。
但是{}表示空字典；set()表示空集合，用set（）创建集合时，会将元素一个一个拆开，如’hello’变成’h’,‘e’,‘l’,‘l’,‘o’。
集合中元素要是固定数据类型：整数、浮点数、字符串、元组等。不可为可变的列表、字典、集合。
利用集合过滤掉重复的元素。
4种基本操作：交（&）、并（|）、差（-）、补（^）
S.add() ;S.clear() ;S.copy() ; S.remove() ;len(S) ;x (not)in S ;
S.pop()：随机返回S中的一个元素，如果S为空，产生KeyError.(区分list.pop([index]))
特有的：S.discard(X)；如果x在S中，移除x，不在，不报错。
主要三大用途：成员关系测试、元素去重、删除数据项。

set1 = {1, 2, 3, (4, 5, 6), "good news"}
set2 = set([1, 2, 3])                 #相当于set2 = {1, 2, 3}， set函数只能传入一个参数
set3 = set((1,2,3))　　                #相当于set3 = {1,2,3}
set4 = set({'a':1,'b':2,'c':3})　      #相当于set4 = {'a','b','c'}

4.函数

在python中函数可以返回多个值：

>>> def f(x, y, z):
	return x, y, z
 
>>> x, y, z = f(1, 2, 3)
>>> print(x, y, z)
1 2 3

但实际上返回的是一个tuple：

>>> res = f(1, 2, 3)
>>> print(res)
(1, 2, 3)
>>>

在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。

函数参数：必选参数，默认参数，可变参数，关键字参数，命名关键字参数

4.1 可变参数与关键字参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了星号（*）的变量名会存放所有未命名的变量参数。不定长参数实例如下：

def printinfo( arg1, *vartuple ):
   print "输出: "
   print arg1
   for var in vartuple:
      print var
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

def arras(x,y,z=4,*param,**params):
    print(x,y,z)
    for i in range(len(param)):
        print(param[i])
    for j in params:
        print(j+':'+params[j])        
arras(1,2,3,4,5,'Python 风格规范(Google)本项目并非Google 官方项目,.。',foo='foo1=100',h00='hoo1=200',koo='koo1=4000')

输出结果：

1 2 3
4
5
Python 风格规范(Google)本项目并非Google 官方项目,.。
foo:foo1=100
h00:hoo1=200
koo:koo1=4000

得出：不定长参数 * 输出一般都是元组的结构形式，**双星输出的都是字典形式的 结构，在传值的中也要确保值得准确匹配才行，不然会报错。

4.2 命名关键字参数

在函数定义时，*后定义的参数，称之为命名关键字参数
特点：命名关键字参数必须按照key=value的形式为其传值

def func(x, y, *, a, b):
    print(x, y, a, b)
func(1, 2, b=4, a=3)
# 输出1 2 3 4

def func(x, y, *, a=111111, b):
    print(x, y, a, b)
func(1, 2, b=22222)
# 输出1 2 111111 22222

4.3 匿名函数

语法：lambda 参数列表 : 表达式
说明：使用lambda关键字创建匿名函数。所谓匿名函数，就是没有名字的函数。匿名函数冒号后面的表达式有且只能有一个，注意：是表达式，而不是语句。匿名函数自带return，而return的结果就是表达式的计算后的结果。
1.无参匿名函数：

>>>t = lambda : True #分号前无任何参数
>>>t()
True
# 等价于
>>> def func(): return True
>>> func()
True 

2.带参数匿名函数

>>> lambda x: x**3 #一个参数
>>> lambda x,y,z:x+y+z #多个参数
>>> lambda x,y=3: x*y #允许参数存在默认值
# 匿名函数调用
>>> c = lambda x,y,z: x*y*z
>>> c(2,3,4)
24
>>> c = lambda x,y=2: x+y #使用了默认值
>>> c(10) #不输的话，使用默认值2
12
>>> a = lambda *z:z  # *z返回的是一个元祖，即返回的是和参数一样的类型
>>> a('Testing1','Testing2')
('Testing1', 'Testing2')

3.直接后面传递实参

>>> (lambda x,y: x if x> y else y)(101,102)
102
>>> (lambda x:x**2)(3)
9
# lambda返回的值，结合map,filter,reduce使用
>>> filter(lambda x:x%3==0,[1,2,3,4,5,6])
[3, 6]

# 等价于下面的列表推导式
>>> l = [x for x in [1,2,3,4,5,6] if x%3==0]
>>> l
[3, 6]

4.嵌套使用

# lambda嵌套到普通函数中,lambda函数本身做为return的值
>>> def increment(n):
             return lambda x: x+n
>>> f=increment(4)
>>> f(2)
6

>>> def say():
			title = 'Sir,'
			action= lambda x: title + x
			return action
>>> act = say()
>>> act('Smith!')
'Sir,Smith!'

5.例子

# 例01:字符串联合，有默认值，也可以x=(lambda...)这种格式
>>> x = (lambda x="Boo",y="Too",z="Zoo": x+y+z)
>>> x("Foo")
'FooTooZoo'

# 例02: 和列表联合使用
>>> L = [lambda x:x**2,
lambda x:x**3,
lambda x:x**4]

>>> for f in L:
... print f(2)
...
4
8
16
# 也可以如下面这样调用
>>> print L[0](3)
9

# 例03: 和字典结合使用
>>> key = 'B'
>>> dic = { 'A': lambda: 2*2,
... 'B': lambda: 2*4,
... 'C': lambda: 2*8}
>>> dic[key]()
8

# 例04: 求最小值
>>> lower = lambda x,y: x if x>> lower('aa','ab')
'aa'

# 例05: 和map及list联合使用
>>> import sys
>>> showall = lambda x:list(map(sys.stdout.write,x))
>>> showall(['Jerryn','Sherryn','Alicen'])
Jerry
Sherry
Alice

>>> showall(['Jerry','Sherry','Alice'])
JerrySherryAlice

#等价于下面
>>> showall = lambda x: [sys.stdout.write(line) for line in x]
>>> showall(('It','Lovet','You!'))
I Love You![None, None, None]

# 例06: 在Tkinter中定义内联的callback函数
import sys
from Tkinter import Button,mainloop
x = Button(text='Press me',
command=(lambda:sys.stdout.write('Hello,Worldn')))
x.pack()
x.mainloop()

>>>
Hello,World!
Hello,World!

# 例07: lambda和map联合使用,

>>>  out = lambda *x: sys.stdout.write(' '.join(map(str,x)))
>>> out('This','is','a','book!n')
This is a book!

# 例08: 判断字符串是否以某个字母开头
>>> print (lambda x: x.startswith('B'))('Bob')
True
>>> Names = ['Anne', 'Amy', 'Bob', 'David', 'Carrie', 'Barbara', 'Zach']
>>> B_Name= filter(lambda x: x.startswith('B'),Names)
>>> B_Name
['Bob', 'Barbara']

# 例09: lambda和map联合使用
>>>  squares = map(lambda x:x**2,range(5))
>>> squares
[0, 1, 4, 9, 16]

# 例10. lambda和map,filter联合使用
>>>  squares = map(lambda x:x**2,range(10))
>>> filters = filter(lambda x:x>5 and x<50,squares)
>>> filters
[9, 16, 25, 36, 49]

# 例11. lambda和sorted联合使用
# 按death名单里面，按年龄来排序
# 匿名函数的值返回给key，进来排序
>>> death = [ ('James',32),
('Alies',20),
('Wendy',25)]
>>> sorted(death,key=lambda age:age[1]) #按照第二个元素，索引为1排序
[('Alies', 20), ('Wendy', 25), ('James', 32)]

# 例12. lambda和reduce联合使用
>>> L = [1,2,3,4]
>>> sum = reduce(lambda x,y:x+y,L)
>>> sum
10

# 例13. 求2-50之间的素数
#素数:只能被1或被自己整除的数
>>> nums = range(2,50)
>>> for i in nums:
nums = filter(lambda x:x==i or x % i,nums)
>>> nums
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]

# 例14. 求两个列表元素的和
>>> a = [1,2,3,4]
>>> b = [5,6,7,8]
>>> map(lambda x,y:x+y, a,b)
[6, 8, 10, 12]

#例15. 求字符串每个单词的长度
>>> sentence = "Welcome To Beijing!"
>>> words = sentence.split()

>>> lengths = map(lambda x:len(x),words)
>>> lengths
[7, 2, 8]

# 写成一行:
>>>  print map(lambda x:len(x),'Welcome To Beijing!'.split())

4.4 python内置函数

Python 内置函数
1.数学相关

abs(a) : 求取绝对值。abs(-1)  
max(list) : 求取list最大值。max([1,2,3])
min(list) : 求取list最小值。min([1,2,3]) 
sum(list) : 求取list元素的和。 sum([1,2,3]) >>> 6
sorted(list) : 排序，返回排序后的list。
len(list) : list长度,len([1,2,3])
divmod(a,b): 获取商和余数。 divmod(5,2) >>> (2,1)
pow(a,b) : 获取乘方数。pow(2,3) >>> 8
round(a,b) : 获取指定位数的小数。a代表浮点数，b代表要保留的位数。round(3.1415926,2) >>> 3.14
range(a[,b]) : 生成一个a到b的数组,左闭右开。 range(1,10) >>> [1,2,3,4,5,6,7,8,9]

2.类型转换

int(str) : 转换为int型。int('1') >>> 1
float(int/str) : 将int型或字符型转换为浮点型。float('1') >>> 1.0
str(int) : 转换为字符型。str(1) >>> '1'
bool(int) : 转换为布尔类型。 str(0) >>> False str(None) >>> False
bytes(str,code) : 接收一个字符串，与所要编码的格式，返回一个字节流类型。bytes('abc', 'utf-8') >>> b'abc' bytes(u'爬虫', 'utf-8') >>> b'xe7x88xacxe8x99xab'
list(iterable) : 转换为list。 list((1,2,3)) >>> [1,2,3]
iter(iterable)： 返回一个可迭代的对象。 iter([1,2,3]) >>> 
dict(iterable) : 转换为dict。 dict([('a', 1), ('b', 2), ('c', 3)]) >>> {'a':1, 'b':2, 'c':3}
enumerate(iterable) : 返回一个枚举对象。
tuple(iterable) : 转换为tuple。 tuple([1,2,3]) >>>(1,2,3)
set(iterable) : 转换为set。 set([1,4,2,4,3,5]) >>> {1,2,3,4,5} set({1:'a',2:'b',3:'c'}) >>> {1,2,3}
hex(int) : 转换为16进制。hex(1024) >>> '0x400'
oct(int) : 转换为8进制。 oct(1024) >>> '0o2000'
bin(int) : 转换为2进制。 bin(1024) >>> '0b10000000000'
chr(int) : 转换数字为相应ASCI码字符。 chr(65) >>> 'A'
ord(str) : 转换ASCI字符为相应的数字。 ord('A') >>> 65

3.功能相关

eval() : 执行一个表达式，或字符串作为运算。 eval('1+1') >>> 2
exec() : 执行python语句。 exec('print("Python")') >>> Python
filter(func, iterable) : 通过判断函数fun，筛选符合条件的元素。 filter(lambda x: x>3, [1,2,3,4,5,6]) >>> 
map(func, *iterable) : 将func用于每个iterable对象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) >>> [6,8,10]
zip(*iterable) : 将iterable分组合并。返回一个zip对象。 list(zip([1,2,3],[4,5,6])) >>> [(1, 4), (2, 5), (3, 6)]
type()：返回一个对象的类型。
id()： 返回一个对象的唯一标识值。
hash(object)：返回一个对象的hash值，具有相同值的object具有相同的hash值。 hash('python') >>> 7070808359261009780
help()：调用系统内置的帮助系统。
isinstance()：判断一个对象是否为该类的一个实例。
issubclass()：判断一个类是否为另一个类的子类。
globals() : 返回当前全局变量的字典。
next(iterator[, default]) : 接收一个迭代器，返回迭代器中的数值，如果设置了default，则当迭代器中的元素遍历后，输出default内容。
reversed(sequence) ： 生成一个反转序列的迭代器。 reversed('abc') >>> ['c','b','a']

5.切片

a=[0,1,2,3,4,5,6,7,8,9]
一个完整的切片表达式包含两个:，用于分隔三个参数start_index, end_index, step。当只有一个:时，默认第三个参数step=1；当一个:也没有时，start_index=end_index，表示切取start_index指定的那个元素。
基本表达式：object[start_index:end_index:step]
step：正负数均可，其绝对值决定了切取数据时的“步长”，正负号决定了“切确方向”，正表示“从左往右”取值，负表示“从右往左”取值。当step省略时，默认为1。
start_index：表示起始索引（包含该索引对应值）。该参数省略时，表示从对象“端点”开始取值，至于是从“起点”还是“终点”开始，则由step参数的正负决定，step为正表示从起点开始，为负表示从终点开始
end_index：表示终止索引（不包含该索引对应值）。该参数省略时，表示一直取到数据“端点”，“端点”同样由step参数的正负决定，step为正时直到“终点”，为负表示直到”起点“

# 1.切取单个元素
print(a[0])
# 0
print(a[-4])
# 6

# 2.切取完整对象
print(a[:])
# [0,1,2,3,4,5,6,7,8,9]
print(a[::])
# [0,1,2,3,4,5,6,7,8,9]
print(a[::-1])
# [9,8,7,6,5,4,3,2,1,0]

# 3.start_index和end_index全为正（负）的情况
print(a[1:6])
# [1,2,3,4,5]
print(a[1:6:-1])
# []
# 输出为空，因为step=-1决定了从右往左取值
# 但是start_index=1及end_index=6决定了从左往右取值，两者矛盾
print(a[6:2])
# []
# 同样输出为空，因为start_index=6到end_index=2决定了从右往左
# 取值，但是step=1又矛盾，因此为空
print(a[:6])
# [0,1,2,3,4,5]
print(a[:6:-1])
# [9,8,7]
print(a[6:])
# [6,7,8,9]
print(a[6::-1])
# [6,5,4,3,2,1,0]

# 4.start_index和end_index正负混合的情况
print(a[1:-6])
# [1,2,3]
print(a[1:-6:-1])
# []
print(a[-1:6])
# []
print(a[-1:6:-1])
# [9,8,7]

# 5.多层切片操作
print(a[:8][2:5][-1:])
# [4]
# 相当于
# a[:8]=[0,1,2,3,4,5,6,7]
# a[:8][2:5]=[2,3,4]
# a[:8][2:5][-1:]=4

# 6.切片操作的三个参数可以用表达式
print(a[2+1:3*2:7%3])
# [3,4,5]

# 7.其他对象的切片操作
print((0,1,2,3,4,5)[:3])
# (0,1,2) tuple的切片操作
print('ABCDEFG'[::2])
# 'ACEG'
for i in range(1,100)[2::3][-5:]:
	print(i)
# 87
# 99
# 93
# 96
# 99

常用切片操作
1.取偶数位置

>>>b = a[::2]
[0, 2, 4, 6, 8]

2.取奇数位置

>>>b = a[1::2]
[1, 3, 5, 7, 9]

3.拷贝整个对象

>>>b = a[:] #
>>>print(b) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>print(id(a)) #41946376
>>>print(id(b)) #41921864
或
>>>b = a.copy()
>>>print(b) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>print(id(a)) #39783752
>>>print(id(b)) #39759176

需要注意的是：[:]和.copy()都属于“浅拷贝”，只拷贝最外层元素，内层嵌套元素则通过引用方式共享，而非独立分配内存，如果需要彻底拷贝则需采用“深拷贝”方式，如下例所示：

>>>a = [1,2,['A','B']]
>>>print('a={}'.format(a))
>>>b = a[:]
>>>b[0] = 9 #修改b的最外层元素，将1变成9
>>>b[2][0] = 'D' #修改b的内嵌层元素
>>>print('a={}'.format(a))
>>>print('b={}'.format(b))
>>>print('id(a)={}'.format(id(a)))
>>>print('id(b)={}'.format(id(b)))
a=[1, 2, ['A', 'B']] #原始a
a=[1, 2, ['D', 'B']] #b修改内部元素A为D后，a中的A也变成了D，说明共享内部嵌套元素，但外部元素1没变。
b=[9, 2, ['D', 'B']] #修改后的b
id(a)=38669128
id(b)=38669192

4.修改单个元素

>>>a[3] = ['A','B']
[0, 1, 2, ['A', 'B'], 4, 5, 6, 7, 8, 9]

5.在某个位置插入元素

>>>a[3:3] = ['A','B','C']
[0, 1, 2, 'A', 'B', 'C', 3, 4, 5, 6, 7, 8, 9]
>>>a[0:0] = ['A','B']
['A', 'B', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

6.替换一部分元素

>>>a[3:6] = ['A','B']
[0, 1, 2, 'A', 'B', 6, 7, 8, 9]

二、数据分析 1.matpltlib

折线图:以折线的上升或下降来表示统计数量的增减变化的统计图特点:能够显示数据的变化趋势，反映事物的变化情况。(变化)
直方图:由一系列高度不等的纵向条纹或线段表示数据分布的情况。一般用横轴表示数据范围，纵轴表示分布情况。特点:绘制连续性的数据,展示一组或者多组数据的分布状况(统计)
条形图:排列在工作表的列或行中的数据可以绘制到条形图中。特点:绘制连离散的数据,能够一眼看出各个数据的大小,比较数据之间的差别。(统计)
散点图:用两组数据构成多个坐标点，考察坐标点的分布,判断两变量之间是否存在某种关联或总结坐标点的分布模式。特点:判断变量之间是否存在数量关联趋势,展示离群点(分布规律)

1.1 折线图

绘制了折线图(plt.plot)
设置了图片的大小和分辨率(plt.figure)
实现了图片的保存(plt.savefig)
设置了xy轴上的刻度和字符串(xticks)
解决了刻度稀疏和密集的问题(xticks)
设置了标题,x,y轴的lable(title,xlable,ylable)
设置了字体(font_manager. fontProperties,matplotlib.rc)
在一个图上绘制多个图形(plt多次plot即可)
为不同的图形添加图例(legend)
绘制网格(plt.grid)

from matplotlib import pyplot as plt  # 导入pyplot

# 设置图片大小
fig = plt.figure(figsize=(20, 8), dpi=80)  # figsize=(10,8)表示长10宽8，dpi参数让图片更清晰

x = range(2, 26, 2)
y = [15, 13, 14.5, 17, 20, 25, 26, 26, 24, 22, 18, 15]
plt.plot(x, y)  # 绘图

# 设置x，y轴刻度
_xtick_label = [i/2 for i in range(4, 49)]
plt.xticks(_xtick_label[::2])  # 太密集时使用列表的步长来解决
plt.yticks(range(min(y), max(y)+1))  # range左闭右开

# 图片的保存
plt.savefig("./1.png")  # 可以保存为svg这种矢量图格式，放大不失真

plt.show()  # 展示图形

from matplotlib import pyplot as plt
import random
from matplotlib import font_manager
# plt.rcParams['font.sans-serif'] = ['SimHei']  # 显示中文标签
# plt.rcParams['axes.unicode_minus'] = False
my_font = font_manager.FontProperties(fname='C:/Windows/Fonts/simhei.ttf')  # 也可以实现中文标签
x = range(0, 120)
y = [random.randint(20, 35) for i in range(120)]
plt.figure(figsize=(20, 8), dpi=80)
plt.plot(x, y)

# 调整刻度
_xtick_label = ["10时{}分".format(i) for i in range(60)]
_xtick_label += ["11时{}分".format(i) for i in range(60)]
plt.xticks(list(x)[::3], _xtick_label[::3], rotation=45, fontproperties=my_font)  # 旋转90度

# 添加描述信息
plt.xlabel("时间", fontproperties=my_font)
plt.ylabel("温度 单位℃", fontproperties=my_font)
plt.title("10点至12点每分钟的气温变化情况", fontproperties=my_font)
plt.show()

绘制多次折线图

from matplotlib import pyplot as plt
from matplotlib import font_manager

my_font = font_manager.FontProperties(fname='C:/Windows/Fonts/simhei.ttf')  # 实现中文标签

a = range(11, 31)
y_1 = [1, 0, 1, 1, 2, 4, 3, 2, 3, 4, 4, 5, 6, 5, 4, 3, 3, 1, 1, 1]
y_2 = [1, 0, 3, 1, 2, 2, 3, 3, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1]

plt.figure(figsize=(20, 8), dpi=80)
plt.plot(a, y_1, label="自己", color="orange", linestyle=':')  # 可调线条颜色、风格、粗细，透明度
plt.plot(a, y_2, label="同桌", color="cyan", linestyle="-.")
_xtick_label = ["{}岁".format(i) for i in a]
plt.xticks(a, _xtick_label, rotation=45, fontproperties=my_font)
plt.yticks(range(0, 9))

plt.grid(alpha=0.4, linestyle=':')  # 绘制网格，alpha为透明度(0-1)，可调线条风格
plt.legend(prop=my_font, loc="upper left")  # 添加图例，loc调图例位置

plt.show()

1.2 散点图

绘制散点图(plt.scatter)

from matplotlib import pyplot as plt
from matplotlib import font_manager

my_font = font_manager.FontProperties(fname='C:/Windows/Fonts/simhei.ttf')  # 实现中文标签
y_3 = [11, 17, 16, 11, 12, 11, 12, 6, 6, 7, 8, 9, 12, 15, 14, 17, 18, 21, 16, 17, 20, 14, 15, 15, 15, 19, 21, 22, 22,
       22, 23]
y_10 = [26, 26, 28, 19, 21, 17, 16, 19, 18, 20, 20, 19, 22, 23, 17, 20, 21, 20, 22, 15, 11, 15, 5, 13, 17, 10, 11, 13,
        12, 13, 6]
x_3 = range(1, 32)
x_10 = range(51, 82)
plt.figure(figsize=(20, 8), dpi=80)  # 调整图形的大小
plt.scatter(x_3, y_3, label="3月份")  # 绘制散点图
plt.scatter(x_10, y_10, label="10月份")

# 调整x的刻度
_x = list(x_3)+list(x_10)
_xtick_label = ["3月{}日".format(i) for i in x_3]
_xtick_label += ["10月{}日".format(i-50) for i in x_10]
plt.xticks(_x[::3], _xtick_label[::3], fontproperties=my_font, rotation=45)

# 添加描述信息
plt.xlabel("时间", fontproperties=my_font)
plt.ylabel("温度", fontproperties=my_font)
plt.title("北京2016年3,10月份每天白天的最高气温", fontproperties=my_font)

# 添加图例
plt.legend(prop=my_font, loc="upper left")

plt.show()

1.3 条形图

横的条形图(plt.bar)
竖的条形图(plt.barh)

from matplotlib import pyplot as plt
from matplotlib import font_manager

my_font = font_manager.FontProperties(fname='C:/Windows/Fonts/simhei.ttf')  # 实现中文标签
a = ["战狼2", "速度与激情8", "功夫瑜伽", "西游伏妖篇", "变形金刚5：最后的骑士", "摔跤吧！爸爸", "加勒比海盗5：死无对证", "金刚：骷髅岛", "极限特工：终极回归", "生化危机6：终章",
     "乘风破浪", "神偷奶爸3", "智取威虎山", "大闹天竺", "金刚狼3：殊死一战", "蜘蛛侠：英雄归来", "悟空传", "银河护卫队2", "情圣", "新木乃伊", ]
b = [56.01, 26.94, 17.53, 16.49, 15.45, 12.96, 11.8, 11.61, 11.28, 11.12, 10.49, 10.3, 8.75, 7.55, 7.32, 6.99, 6.88,
     6.86, 6.58, 6.23]

plt.figure(figsize=(20, 15), dpi=80)
plt.barh(range(len(a)), b, height=0.3, color="orange")  # 横的条形图
plt.yticks(range(len(a)), a, fontproperties=my_font)  # 设置字符串到y轴

'''
plt.bar(range(len(a)), b, width=0.3, color="orange")  # 竖的条形图
plt.xticks(range(len(a)), a, fontproperties=my_font)
'''
plt.grid(alpha=0.3)
plt.show()

绘制多次条形图

from matplotlib import pyplot as plt
from matplotlib import font_manager
my_font = font_manager.FontProperties(fname='C:/Windows/Fonts/simhei.ttf')  # 实现中文标签
a = ["猩球崛起3：终极之战", "敦刻尔克", "蜘蛛侠：英雄归来", "战狼2"]
b_16 = [15746, 312, 4497, 319]
b_15 = [12357, 156, 2045, 168]
b_14 = [2358, 399, 2358, 362]
bar_width = 0.2
x_14 = list(range(len(a)))
x_15 = [i+bar_width for i in x_14]
x_16 = [i+bar_width for i in x_15]
plt.figure(figsize=(20, 15), dpi=80)
plt.bar(x_14, b_14, width=bar_width, label="2017-09-14(b_14)")
plt.bar(x_15, b_15, width=bar_width, label="2017-09-15(b_15)")
plt.bar(x_16, b_16, width=bar_width, label="2017-09-16(b_16)")
plt.xticks(x_15, a, fontproperties=my_font)
plt.legend(prop=my_font)
plt.show()

1.4 直方图

绘制直方图(plt.hist)
一般来说能够使用plt.hist方法的的是那些没有统计过的数据
直方图用来将数据分组统计，组数=极差/组距

from matplotlib import pyplot as plt
from matplotlib import font_manager

my_font = font_manager.FontProperties(fname='C:/Windows/Fonts/simhei.ttf')  # 实现中文标签
a = [131, 98, 125, 131, 124, 139, 131, 117, 128, 108, 135, 138, 131, 102, 107, 114, 119, 128, 121, 142, 127, 130, 124,
     101, 110, 116, 117, 110, 128, 128, 115, 99, 136, 126, 134, 95, 138, 117, 111, 78, 132, 124, 113, 150, 110, 117, 86,
     95, 144, 105, 126, 130, 126, 130, 126, 116, 123, 106, 112, 138, 123, 86, 101, 99, 136, 123, 117, 119, 105, 137,
     123, 128, 125, 104, 109, 134, 125, 127, 105, 120, 107, 129, 116, 108, 132, 103, 136, 118, 102, 120, 114, 105, 115,
     132, 145, 119, 121, 112, 139, 125, 138, 109, 132, 134, 156, 106, 117, 127, 144, 139, 139, 119, 140, 83, 110, 102,
     123, 107, 143, 115, 136, 118, 139, 123, 112, 118, 125, 109, 119, 133, 112, 114, 122, 109, 106, 123, 116, 131, 127,
     115, 118, 112, 135, 115, 146, 137, 116, 103, 144, 83, 123, 111, 110, 111, 100, 154, 136, 100, 118, 119, 133, 134,
     106, 129, 126, 110, 111, 109, 141, 120, 117, 106, 149, 122, 122, 110, 118, 127, 121, 114, 125, 126, 114, 140, 103,
     130, 141, 117, 106, 114, 121, 114, 133, 137, 92, 121, 112, 146, 97, 137, 105, 98, 117, 112, 81, 97, 139, 113, 134,
     106, 144, 110, 137, 137, 111, 104, 117, 100, 111, 101, 110, 105, 129, 137, 112, 120, 113, 133, 112, 83, 94, 146,
     133, 101, 131, 116, 111, 84, 137, 115, 122, 106, 144, 109, 123, 116, 111, 111, 133, 150]
bin_width = 3  # 设置组距
num_bins = int((max(a) - min(a)) / bin_width)  # 计算组数
plt.figure(figsize=(20, 15), dpi=80)

# plt.hist(a, [min(a) + i * bin_width for i in range(num_bins)])  # 传一个列表，长为组数，值为分组依据，这样划分更精确
# plt.hist(a, range(min(a), max(a) + bin_width, bin_width)) 这样也行
plt.hist(a, [min(a) + i * bin_width for i in range(num_bins)], density=True)  # 频率分布直方图

plt.xticks(range(min(a), max(a) + bin_width, bin_width))  # 设置刻度
plt.grid(alpha=0.5)
plt.show()

条形图代替直方图

from matplotlib import pyplot as plt
interval = [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 60, 90]
width = [5, 5, 5, 5, 5, 5, 5, 5, 5, 15, 30, 60]
quantity = [836, 2737, 3723, 3926, 3596, 1438, 3273, 642, 824, 613, 215, 47]

# 条形图代替直方图

# 设置图形大小
plt.figure(figsize=(20, 8), dpi=80)
plt.bar(range(12), quantity, width=1)
# 设置x轴的刻度
_x = [i - 0.5 for i in range(13)]  # 向左偏移一半
_xtick_labels = interval + [150]
plt.xticks(_x, _xtick_labels)

plt.grid(alpha=0.4)
plt.show()

2.numpy 3.pandas 三、数学建模

---

总结

提示：这里对文章进行总结：

例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。