初识python(入门笔记篇)

python学习笔记分享

第一篇技术blog，来写写学习python入门的基础点（类似重点笔记），并非系列教程，没有废话，只输出干货，笔者文笔不佳可能还有错别字，欢迎找错&补充。

1.python安装

本来所有入门篇都会有软件安装的步骤，但是安装实在太简单，网上教程很多，无非就是下载安装包，安装ing，安装成功，[简单配置]；所以这里不做介绍，笔者用到的是python3.6，win10。

2.数据类型

1. 数字

   变量数据类型随着赋值的类型而改变，如 a=1 此时a的类型是Int，a=‘1’ 此时a的类型是字符串，a=False 此时a的类型是布尔。
   数学运算：数字除法运算有两种方式，一种用10/3得到的数是精确值3.33333333335，另一种是10//3得到的数是整数结果3。

2. 字符

   字符串以Unicode编码（两个字节表示一个字符），如字母A用ASCII标识是01000001，用Unicode表示是00000000 01000001，用UTF-8表示是01000001汉字“中”用ASCII表示不了，用Unicode表示是01001110 00101101，用UTF-8表示是11100100 10111000 10101101。
   ord()函数回去字符的正数编码，chr()函数把编码转换为对应的字符
   取字符串的字符长度用len(’’)函数，取字符串的字节长度用len(’’.encode(‘utf-8’))函数，先将字符转换为utf-8编码再取长度。
   如果.py文件中有中文字符使用，就必须要在文件头添加注释：# -- coding: utf-8 -- 用于告诉Python编译器，按照UTF-8编码读取源代码，否则源代码中写的中文可能会乱码。

延申：格式化
格式化用%百分号，%s表示字符串占位符，%d表示整数占位符，%?表示不限制类型有几个占位符就替换几个；任何类型都可以使用%s做占位符；

占位符	说明
%d	整数占位符
%f	浮点数占位符
%s	字符串占位符
%x	十六进制正数占位符

3.List&Tuple

3.1 List集合

集合里面可以放不同类型的变量、集合的长度用len函数可以获取，获取某行索引值可以用集合对象[索引值]获取，如classmates=[‘a’,‘b’,‘c’,‘d’,22,33]，获取第3个索引值：classmates[[2]];

集合索引从0开始，最大索引值是len-1，如果要获取索引最后一个索引值，可以直接使用-1索引，如classmates[-1]。

添加：List是一个可变的有序表，可以在末尾追加数据，追加数据用append(‘数据’)函数，也可以在索引内指定位置插入，插入用insert（索引，数据）。

删除：要删除末尾的元素，可以用pop()函数，pop函数的返回值是被删除的数据值，如classmates.pop()返回33，如果要删除指定位置的元素，用pop(索引值)进行删除。

二维表：集合[集合a,集合b,集合c]，List内的元素可以是集合，获取二维表的数据时直接用：集合[父索引][子索引]，三维表、四维表、n维表都是一样的套路。

3.2 tuple

tuple就是一个有序不可变的列表，长度一旦定义，就不能修改，如果tuple中的元素不是基础数据类型，而是List的话，其实内容是可变的，

如：a=1 b=2 c=3 d=[11,22,33] e=(a,b,c,d) 此时e的值是（1,2,3,[11,22,33]）,更改d[1]=111,d[2]=222，此时e的值是（1,2,3,[111,222,333]）

所以，tuple严格意义上应该是指向是固定不变的，但是指向的变量值是可变的。

4.Dict&Set

4.1 Dict

dict类似Java中的map，是一个键值对的对象，定义可以用大括号{}，
如：per = {‘age’:18,‘name’:‘Anna’,‘sex’:‘Woman’}。

取值可以使用per[‘key名称’]，在取值之前如果不确定当前key是否存在于dict中，可以使用in 条件去判断，如 if ‘key’ in dictS。

dict内部存放的顺序和key放入的顺序是没有关系的，dict内部的内容顺序是不定的；dict的key必须是不可变对象。dict根据key查找value值的算法用到的是哈希hash。dict中的key可以是字符串或整数（不可变）。

4.2 Set

set就是一组没有重复值的不可变集合，set的创建需要传入一个list作为输入集合：set_a=set([1,2,3,4,5])。
如果set的内容是set([1,1,2,2,3,3])，最终set只会存储为[1,2,3]，set会自动过滤掉重复元素。
添加元素：可以使用add（element）函数往set中添加元素，如：set_a.add(5)。
删除元素：可以使用remove(element)函数删除set中的元素，如：set_a.remove(1)。

set相当于数学中的无序元素唯一的集合，两个set可以做交集、并集操作，如： set1=set([1,2,3]) set2=set([2,3,4,5])
交集运算：s1&s2 结果就是{2,3}
并集预算：s1|s2 结果就是{1,2,3,4,5}

set中只能存放字符串或者数字（可以直接比较的对象），这些对象不可变。不能存放list元素（可变的）。
代码：

>>> set1=set([1,2,3])
>>> set2=set([2,3,4,5])
>>> set1&set2{2, 3}
>>> set3=set1|set2
>>> set3{1, 2, 3, 4, 5}
>>> set2.add('s')
>>> set3=set1|set2
>>> set3{1, 2, 3, 4, 5, 's'}

5.可变对象&不可变对象

5.1 可变对象

对可变对象进行操作，对象的内容会随之变化：如list对象：a=[1,3,2,3]对a进行sort之后a的内容变成了[1,2,3,3]。

这个过程是这样的：
1.
a[0]-----指向----->1
a[1]-----指向----->3
a[2]-----指向----->2
a[3]-----指向----->3
2.sort之后:
a[0]-----指向----->1
a[1]-----指向----->2
a[2]-----指向----->3
a[3]-----指向----->3

5.2 不可变对象

对不可变对象进行操作，对象的内容不会随之变化：如字符串：a=‘abc’，对a进行replace(‘a’,‘A’)，a不会随之变化，a的结果还是’abc’。

重点：a是变量，‘abc’才是字符串对象，变量a指向了字符串对象’abc’，而a本身没有方法，repalce方法其实是字符串对象’abc’的方法，并且因为字符串是不可变对象，所以在调用replace方法时并不会改变’abc’对象本身的值，而是创建了一个新的’Abc’对象，如果不使用变量接收这个新的字符串对象，那么这个对象就没有被指向引用。

对于不可变对象来说，调用对象自身的任意方法，都不会改变对象的内容，这些方法会创建新的对象并返回，就可以保证不可变对象永远不可变，不会被更改。

6.语法23&函数23

6.1 简单语法

一、IF条件判断

在判断条件后面必须加冒号：，IF判断条件内的执行语句必须要有缩进，如果没有缩进会直接按顺序执行。
else if 可以用缩写elif代替，
if判断条件也可以缩写，类似js的if缩写，只要条件是非零数值、非空字符串、非空lIst，条件就是True，否则是False。

二、循环

可以使用for xx in xxs循环遍历List或者tuple,xxs可以是定义好的LIst变量，也可以是临时List或者tuple。可以使用range(整数值)生成一个整数值长度的从0-整数值的序列，可以用list(range(n))来获取有n个值的集合。结束并跳出循环使用break，跳出单个循环用continue。

6.2 函数

6.2.1常用函数

绝对值函数：abs(n)，最大值函数max(1…n)可以接受多个参数并返回最大值，取十六进制值函数：hex(整数)

类型转换函数：int(str);int(float)，float(str)，str(int);str(float)，bool(int),bool(str),bool(float)

input函数接收到的输入返回值都是字符串类型，不能直接做数字比较，字符串类型可以用int(字符串)函数来转换成整数型。

6.2.2函数别名

可以给函数指定一个变量别名，如：a=abs，语法是：别名=函数名

6.2.3函数定义

函数定义语法：

def funname(param..):
	方法体
	[return]可选，不写默认会返回None

如：

>>> def gessBest(str1,str2):
...     if "lxh"==str1:
...             print(str1,'most beutiful')
...     else:
...             print(str1,'bad one')
...
>>> gessBest('lxh','')
lxh most beutiful
>>> gessBest('lxss','')
lxss bad one

6.2.4调用自定义函数

如果把自定义函数保存在了newFun.py文件中，可以使用from newFun import getAbs引入函数，再进行 getAbs(参数)进行调用，引入的语法是：from py文件名 import 自定义函数名称。
如：在newFun.py文件中定义：

#定义函数
def getAbs(param):
if param>0:
return param
else:
return -param

在python交互命令行里执行：from newFun import getAbs后，就可以调用getAbs函数。

空函数：如果要定义一个什么都不做的函数，可以在函数体里面写一个pass就可以，缺少pass代码允许会报错（语法不对）。

6.2.5参数检查

可以使用isinstance(参数,(类型1，类型2…))来判断传递的参数是否符合类型要求，如判断参数是否是数值类型：if isinstance(param,(int,float)):

6.2.6函数返回值

函数的返回值可以是多个，python函数返回多个值实际上返回的是一个tuple对象，只是在return的时候可以省略括号，比如return 1,2；实际上是返回了一个（1,2）的tuple，这个返回值可以使用多个变量去接收，x,y = fun(xx)。如果是返回一个值，就不是tuple，就是相应的返回值对象类型。如果没有返回值，默认返回return None。

6.2.7函数参数

6.2.7.1函数默认参数

如果一个函数的参数可以选填，并且不填的时候也可以按照默认值执行的话，就可以使用默认参数，如：newFun(x=2): 如果调用newFun函数时不传递参数x,默认执行时会调用x=2，使用2去执行函数体。默认参数要放在必选参数后面定义。一般可以把变化大的参数放在前面定义，变化小的参数放在后面定义。

6.2.7.2调用函数不按参数定义顺序传递参数

如果不明确喊出的参数顺序，可以不按照参数顺序去传递参数，但是此时就需要在传递时把参数名称写上，如函数：newFun(name,age,sex,school):

调用的时候如果不确定顺序，可以这样调用 newFun(‘zhangsan’,sex=‘男’,age=21,school=‘北大’)

默认参数最好是不要使用可变对象（list），可变对象默认参数如果不传递参数值而使用默认值，调用多次函数后，默认参数值会递增
如：

>>> def nf(l=[]):
...     l.append('end')
...     return l
>>> nf([1,2])
[1, 2, 'end']
>>>> nf([1,2])
[1, 2, 'end']
>>> nf()
['end']
>>> nf()
['end', 'end']
>>> nf()
['end', 'end', 'end']

如果一定要使用可变对象作为默认参数的话，最好在方法体中做重新初始化赋值，如：

>>> def nf(l=None):
...     if l is None:
...             l=[]
...     l.append('end')
...     return l
...
>>> nf()
['end']
>>> nf()
['end']
>>> nf()
['end']

6.2.7.3可变个数的函数参数

可以使用 *参数 来表示可变个数的参数，如def calc(*numbers)，numbers就是一个可变参数，并且numbers接收到的是一个tuple，在调用函数的时候就可以传入任意个参数，也可以不传递参数，如：

>>> def calc(*numbers):
...     sum=0
...     for n in numbers:
...             sum = sum+n*n
...     return sum
...
>>> calc()
0
>>> calc(2)
4
>>> calc(2,3,4)
29
>>> calc(2,3,4,5)
54

如果已经有一个需要传递的参数tuple，可以在调用函数传递参数时，在变量前面加*星号传递，如：

>>> vn=[1,2,3,4,5]
>>> calc(*vn)
55

6.2.7.4关键字参数

关键字参数也允许传入0-n个参数，但是参数必须定义参数名称，这些参数在函数内部会组装成一个dict。定义语法是用两个**星号，如

>>> def showPer(name,age,**others):
...     print(name,age,'other:',others)
>>> showPer('zhangsan',28)
zhangsan 28 other: {}
>>> showPer('zhangsan',28,school='清华大学',email='zhangsan@sina.com')
zhangsan 28 other: {'school': '清华大学', 'email': 'zhangsan@sina.com'}

如果已经有一个dict的参数变量，也可以跟可变参数的list传递一样，在传递的时候在参数变量前面加两个**星号，如：

>>> pers={'school':'华东科技大','email':'lisi@sina.com'}
>>> showPer('lisi',21,**pers)
lisi 21 other: {'school': '华东科技大', 'email': 'lisi@sina.com'}

上面的代码中**pers意思是把pers这个dict的所有k-v用于关键字参数传入到函数showPer的other关键字参数内，这样other就会获取到一个备份的pers的dict备份。

6.2.7.5命名关键字参数

命名关键字参数就是给关键字参数设置一个命名限制，比如在函数体中可能只用到dict的city和school两个key的值，那么如果不使用命名关键字参数则可能造成传递参数冗余的现象，如果在关键字参数中规定只需要传递key是city和school的两个参数就能解决这个问题，命名关键字参数的定义语法是fun(位置参数,**这里是一个星号编辑器有问题,命名关键字参数1,…)，其中*星号前面的参数都是位置参数，*星号后面的参数都是命名关键字参数。如：

>>> def showPer(name,age,*,city,school):
...     print(name,age,city,school)
>>> showPer('wangwu',30,city='上海',school='s')
wangwu 30 上海 s

需要注意的是，命名关键字参数在调用的时候必须要传入参数名称，不然会报错。

end:如果一个函数内使用了位置参数，默认参数，可变参数，关键字参数，命名关键字参数的时候，要注意参数的定义顺序，必须是位置参数、默认参数、可变参数、命名关键字参数、关键字参数。
函数递归调用的时候最后的返回return一定要通过尾递归防止栈溢出，就是在函数返回的时候，调用函数自身，并且return语句不能包含表达式，可以是return newFun(a,b,c,a+4);单不可以是 return a+newFun(b);

初识基础篇到此结束，后面有时间再更新一些高阶。欢迎大家补充&指正，thx~