python基础知识的一些梳理

1.安装anaconda后 anaconda powershell prompt 和anaconda prompt之间的区别：powershell多了更多linux命令，比如pwd和ls

2.字符串前面加r就是防止转义字符的，以下是等效的：

os.chdir("C:\\Users\\earth\\Desktop\\Nanodegree\\image_classification-master")
os.chdir(r"C:\Users\earth\Desktop\Nanodegree\image_classification-master")
os.chdir("C:/Users/earth/Desktop/Nanodegree/image_classification-master")

3.python运行：1.可以直接在命令行中用 python 文件名.py
2.在jupyter notebook的某个单元格中用shift+enter
3.在jupyter notebook中%run 文件名.py

4.几个函数zip,enumerate,set
(1).enumerate:用于将一个可遍历的数据对象，同时列出数据和数据下标

l1=['张三','李四']
for _,item in enumerate(l1):
    print(_,item) 
#enumerate(l1)的结果是[(0,'张三'),(1,'李四')]

(2).zip:是对应位置的拼接，数量不相等的时候也不会报错，但是会把对应不到的元素忽略掉

list1 = [1, 2, 3]
list2 = ['one', 'two', 'three']
dict(zip(list1, list2))
#结果是{1: 'one', 2: 'two', 3: 'three'}

(3)set:集合里的元素是无序且不重复的，可以用来对列表去重，也可以用来取交集，并集，差集

obj = ['a','b','c','b','a']
set(obj) #输出{'a', 'b', 'c'}

A = set('hello')
B = set('world')
#A是{'e', 'h', 'l', 'o'}，B是{'d', 'l', 'o', 'r', 'w'}
A.union(B)  #输出{'d', 'e', 'h', 'l', 'o', 'r', 'w'}
A.intersection(B)#输出{'l', 'o'}
A.difference(B) #输出{'e', 'h'}，就是A有B没有

(4)eval,是把字符串转换成表达式并执行，可以配合input()一起使用

x=input()
print(eval(x))#一个简单的四则运算器，直接输入一个公式
type(eval('[1,2,3]'))#输出list
eval('max([2,4,5])')#输出5

(5)map,map函数会把序列里的每1个元素用指定的方法加工一遍
需要对DataFrame按行或者按列操作时，用apply
需要对DataFrame所有数据操作时，用applymap
需要对Series等一维的数据操作时，用map

chars = ['apple','watermelon','pear','banana']
a = map(lambda x:x.upper(),chars)
list(a)# 输出['APPLE', 'WATERMELON', 'PEAR', 'BANANA']

nums = [1,2,3,4]
a = map(lambda x:x*x,nums)
list(a))#输出[1,4,9,16]

l1=[2,3,5,5,2]
a=map(lambda x:(x,l1.count(x)),l1)
list(a)#输出[(2, 2), (3, 1), (5, 2), (5, 2), (2, 2)]，就是类似与excel的countif

(6）filter,作为筛选条件，把序列中符合条件的元素筛选出来

nums = [1,2,3,4,5,6]
a = filter(lambda x:x%2!=0,nums)
list(a)# 输出：[1,3,5]

l1=[2,3,'shy',[2,3,3],5,2]
list(filter(lambda x:True if type(x)==str else False,l1))#写的有点复杂
list(filter(lambda x:type(x)==str,l1))#这样写，就比较简单，和上面一句是等效的
#把字符串找出来

(7)reduce,会对参数序列中元素进行累积计算，比如所有元素相加，或者所有元素相乘

from functools import reduce
nums = [1,2,3,4]
reduce(lambda x,y:x*y,nums)#输出24

chars = ['a','p','p','l','e']
reduce(lambda x,y:x+y,chars)#输出'apple'

(8)sorted,可以和匿名函数配合使用

chars = ['apple','watermelon','pear','banana']
sorted(chars,key=lambda x:len(x))# 输出：['pear', 'apple', 'banana', 'watermelon']

tuple_list = [('A', 1,5), ('B', 3,2), ('C', 2,6)]
sorted(tuple_list, key=lambda x: x[1])#输出：[('A', 1, 5), ('C', 2, 6), ('B', 3, 2)]

d1={'c':15,'i':9,'u':2,'j':1.5}
sorted(d1.items(),key=lambda x:(x[0]))#输出[('c', 15), ('i', 9), ('j', 1.5), ('u', 2)]

5.extend和append,如果扩展元素是列表，append会把整个列表当成1个元素添加，而extend则是会把列表内的元素一个个添加

a=[2,3,4]
a.extend([5,6]) #这时候输出的是[2,3,4,5,6]
a.append([5,6])#这时候输出的是[2, 3, 4, [5, 6]]

6.python可变对象与不可变对象：可变对象如果要变化，并不会开辟新的内存
可变对象:一个对象在不改变其所指向的地址的前提下，可以修改其所指向的地址中的值；
不可变对象:一个对象所指向的地址上值是不能修改的，如果你修改了这个对象的值，那么它指向的地址就改变了，相当于你把这个对象指向的值复制出来一份，然后做了修改后存到另一个地址上了，但是可变对象就不会做这样的动作，而是直接在对象所指的地址上把值给改变了，而这个对象依然指向这个地址。
可变对象可以通过引用其元素，改变对象自身；列表是，字典，集合是可变对象，字符串是不可变对象

a=b=c=[1,2,3]
print(a,b,c) #输出[1, 2, 3] [1, 2, 3] [1, 2, 3]
a.append(4)
print(a,b,c)#输出[1, 2, 3, 4] [1, 2, 3, 4] [1, 2, 3, 4]
print('id(a):',id(a),'id(b):',id(b),'id(c):',id(c))#输出id(a): 2220184043464 id(b): 2220184043464 id(c): 2220184043464内存地址是一样的

a=b=c='beijing'
print(a,b,c)#输出a=b=c='beijing'
a='shanghai'
print(a,b,c)#shanghai beijing beijing
print('id(a):',id(a),'id(b):',id(b),'id(c):',id(c))#输出id(a): 2220184297776 id(b): 2220184297968 id(c): 2220184297968 可以发现内存地址是不一样的

7.浅复制和深复制：区别主要在于原始对象更改可变元素是否会造成新的对象的改变，浅会改，深不会改
浅复制就是对引用的拷贝：原始对象对于可变元素的更改会影响新的对象
浅复制它拷贝的是浅层次的数据结构（不可变元素），对象里的可变元素作为深层次的数据结构并没有被拷贝到新地址里面去，而是和原对象里的可变元素指向同一个地址

引用，原对象怎么变，新对象就怎么变。但是对于不可变对象，其实不存在引用，新建了一个内存地址
浅复制，可变对象会变，不可变对象不会变
深复制，原对象再怎么变和新对象没有什么关系。

from copy import copy
e=['hello',[1,2,3]]
f=copy(e)# 和f=e[:]是等效的
print([id(x) for x in e])#[3034426207664, 3034426163144]
print([id(x) for x in f])#[3034426207664, 3034426163144]
e[0]='world'
e[1].append(4)
print(e)#输出['world', [1, 2, 3, 4]]
print(f)#['hello', [1, 2, 3, 4]]

深复制:原始对象的改变不会造成深复制里任何子元素的改变

from copy import deepcopy
a=['hello',[1,2,3]]
b=deepcopy(a)

#此时2个字符串的ID是一致的
print([id(x) for x in a])#输出[3034426207664, 3034425133512]
print([id(x) for x in b])#输出[3034426207664, 3034426086024]
a[0]='world'
a[1].append(4)
print(a)#输出['world', [1, 2, 3, 4]]
print(b)#输出['hello', [1, 2, 3]]

字典父对象拷贝，子对象引用

dict1=  {'user':'runoob','num':[1,2,3]} 
dict2 = dict1          # 浅拷贝: 引用对象
dict3 = dict1.copy()   # 浅拷贝：深拷贝父对象（一级目录），浅拷贝子对象（二级目录）,字典没有deepcopy的方法

dict1['user']='root'
dict1['num'].remove(1)

print(dict1) #输出{'user': 'root', 'num': [2, 3]}
print(dict2)#输出{'user': 'root', 'num': [2, 3]}
print(dict3)#输出{'user': 'runoob', 'num': [2, 3]}