python入门

教程地址：python入门 - 慕课网

安装python 执行脚本

python官网

直接选最高版本学习

安装程序，并将python.exe加入系统环境变量。

选自定义

全选

加入环境变量

Python命令行模式可以exit()命令退出

记得配置完环境变量后要重新打开一个cmd，不然不起作用啊，好气

命令行执行脚本

配置下sublime可以直接执行python脚本吧。

Sublime text工具-编译系统-自动就好了ctrl+b执行脚本

数据类型

1.整数

    a)200，-10，0

    b)二进制（1010），八进制（0777），十进制（444），十六进制(0x45af)这些。

    c)八进制表示数字前必须加上0（零），十六进制表示数字前必须加上0x.

2.浮点数

    a)0.7  -0.56  0.0004

    b)科学计数法1.23*10^9 => 1.23e9  0.000012 => 1.2e-5

3.字符串

    a)‘abc’      “abc”

    b)‘ab”c’       “ab’c”      “ab\”c”(\为转义符)

4.布尔值

    a)Ture (真)

    b)False (假)

    c)布尔值可以用and、or和not运算。其实就是与或非

5.空值

    a)空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

    b)print(0==None) #False

Print语句

在3.6中print语句要使用()包起来，而2.7则不需要。

都可以使用,（逗号）分隔，打印多个结果

print('100 + 200 =', 100 + 200)

注释#

Python的注释以#开头，后面的文字直到行尾都算注释

#我是一行注释....

变量

Python的声明变量与php声明变量一样简单，都不用指定变量的数据类型，而且不需要php的$符号

和大多数语言一样，变量名由字母数字下划线组成，且不能以数字开头

例子

a = 'ABC'

b = a   #这里的赋值是值传递

a = 'XYZ'

print (b,'\n') #ABC

对比php中则存在通过加&符引用传递

php引用传递

raw字符串

使用r开头，表示这是一个raw字符串，里面的字符不需要转义

r'\(~_~)/ \(~_~)/'

多行字符串‘’’...’’’ 

'''Line 1

Line 2

Line 3'''

python中的整形和浮点型

在2.7版本中，整数之间相除为整数，不会保留小数点，只取整。11/4 = 2

在我使用的3.6版本中就不存在这个问题。11/4 = 2.75

python中的布尔类型

Python把0、空字符串''和None看成False，其他数值和非空字符串都看成True

Python中的and,or,not就是对应php中的&&,||,!，且存在短路原则。

a = True

print(a and 'a=T' or 'a=F')   #a=T

列表list

List是一种有序的集合，使用[]，将元素括起来，没有元素就表示一个空list

创建list :L = ['Adam', 'Lisa', 'Bart']

与大多数语言一样，列表list的索引是从0开始的，可以通过 变量[索引] 来访问list中的元素

通过索引访问list :  print(L[1])   #Lisa

访问不存在的索引就会报错

倒序访问list :  print(L[-1])  #Bart

倒序访问list :  print(L[-2])  #Lisa

一样越界会报错:  print(L[-4])  #报错

往list列表添加新元素

append()方法  将新元素追加到list末尾

L.append('Paul')

print(L)   #['Adam', 'Lisa', 'Bart', 'Paul']

Insert()方法，它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素

当参数1索引存在的时候，新元素被插入到指定位置，且这个索引后的元素，索引向后推一位。

当参数1索引不存在的时候，新元素就是追加在list末尾，自动分配索引

同样的，也接受负数作为倒序的索引

L.insert(100,'Paul')

L.insert(4,'test')

L.insert(-4,'test111')

print(L)  #['Adam', 'test111', 'Lisa', 'Bart', 'Paul', 'test']

从list列表删除元素

使用pop()方法，当不给pop方法传递索引时，默认删除list中的最后一个元素（其实就是默认-1）

传入索引，则根据索引查找，并删除

pop()方法会返回被删除掉的元素

L = ['Adam', 'Lisa', 'Bart', 'Paul']

print(L.pop()) #Paul

print(L) #['Adam', 'Lisa', 'Bart']

print(L.pop(0)) #Adam

print(L) #['Lisa', 'Bart']

print(L.pop(-2)) #Lisa

print(L) #['Bart']

索引越界会直接报错。pop()删除空list里面元素的时候同样会报错

替换list中的元素

其实就是给指定的索引赋值，越界报错，可以使用负数索引

L[-1] = 'Paul'

元组tuple

tuple是另一种有序的列表,tuple使用()把元素括起来。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。

创建tuple :t=('Adam', 'Lisa', 'Bart')

Tuple与list一样，可以通过索引访问：

t = ('Adam', 'Lisa', 'Bart')

print(t) #('Adam', 'Lisa', 'Bart')

print(t[1]) #Lisa

print(t[-3]) #Adam

创建单个元素的tuple

因为()既可以表示tuple，也可以表示运算时的优先级，所以类似这样的时候存在歧义。

t = ('string')  #string

t = (10086) #10086

正是因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义：

t = ('string',)

print(t) #('string',)

“可变”的tuple

t = ('a', 'b', ['A', 'B'])

L = t[2]

L[0] = 'X'

L[1] = 'Y'

print(t) #('a', 'b', ['X', 'Y'])

指向不变：tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

Python代码的缩进

具有相同缩进的连续代码行被视为代码块。没有像php那种{}

Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格

If语句

if条件:

    代码块

If-else

if条件:

    代码块

else:

    代码块

If-elif-else

if条件:

    代码块

elif :

    代码块

else :

    代码块

#这个elif就是指else if的意思。

总体上if else这些和其他语言一样，就是注意没有{}括号，而已相同的连续缩进为代码行为代码库，以:开始代码库标识，还有else if简写为elif就是了。

for循环

list或tuple可以表示一个有序集合。可以使用for循环依次访问一个其中的每一个元素

L = ('Adam', 'Lisa', 'Bart')

for name in L:

    print(name)

L = [75, 92, 59, 68]

sum = 0.0

for score in L:

    sum += score

print(sum / 4)

while循环

和其他主流语言一样，都是当满足条件，执行while代码块。否则跳槽循环。

N = 10

x = 0

while x < N:

    print(x)

    x = x + 1

用 for 循环或者 while 循环时，如果要在循环体内直接退出循环，可以使用 break 语句。

在循环过程中，可以用 break 退出当前循环，还可以用 continue 跳过后续循环代码，继续下一次循环。

嵌套循环

在循环内部，嵌套循环。这种开发过程中是很常见的。

for x in [1,2,3,4,5,6,7,8,9]:

    for y in [0,1,2,3,4,5,6,7,8,9]:

        if x

            print(x*10 + y)

字典dict

Dict是key-value的键值对集合，使用大括号{}包裹。

创建一个dict字典，赋值给变量d：

d = {

    'Adam': 95,

    'Lisa': 85,

    'Bart': 59

}

定义的时候，重复的key会取代上一个。还有关于这个key可以是整形，浮点型，字符串都行的。

d = {

    'Adam': 95,

    'Lisa': 85,

    'Bart': 59,

    1.5:50,

    1.5:51,

    '<"\'>':11

}

print(d) #{'Adam': 95, 'Lisa': 85, 'Bart': 59, 1.5: 51, '<"\'>': 11}

与list和tuple不同的是，dict通过key来访问其中的元素。

d['Adam']  #95

当key存在时，返回其对应的value，否则报keError错误

要避免KeyError 发生，有两个办法：

一是先判断一下key 是否存在，用 in 操作符：

if 'Paul' in d:

    print(d['Paul'])

二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None：

print(d.get('Bart')) #59

print(d.get('Paul')) #None

len()函数可以计算任意集合的大小，包括list,tuple,dict,字符串也行

len([1,2,3])   #3

字典dict的特点

dict是无序的。

dict中做为key的元素是不可变的，其中字符串，整数，浮点数都是不可变的，list不行，每个元素都是不可变对象的tuple也是不可变的，可以作为key。

{('a','b'):1}   #可以

{('a','b',['c']):1} #不行，存在list

更新字典dict

dict是可变的，可以随时往dict中添加新的key-value

使用dict[key]=value的语法，存在则替换，不存在则添加。

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59}

d['a']='dada';

d['Bart']=100;

print(d)  # {'Adam': 95, 'Lisa': 85, 'Bart': 100, 'a': 'dada'}

遍历字典dict

使用for in遍历

for key in d:

    print(key,':',d[key])

#拿到key之后使用dict[key]取其对应的value

set数据类型

dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的。

只想要dict 的 key，不关心 key 对应的 value，目的就是保证这个集合的元素不会重复，set就是符合这种需求。

set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。

创建set方法：调用set()并传入一个list,list的元素将作为set的元素

s = set(['A', 'B', 'C'])

print(s)  #{'A', 'C', 'B'} 元素的顺序和初始传入的不同，set是无序的，随机的

也可以直接这样：

s={'A', 'C', 'B'}

Set不能包含重复的元素，传入的重复元素会被自动去重。

访问set

由于set存储的是无序集合，所以我们没法通过索引来访问。

访问set中的某个元素实际上就是判断一个元素是否在set中。

使用in操作符判断

s={'A', 'C', 'B','B'}

print('A' in s)   #True

print('a' in s)   #False

更新set

使用add()方法添加元素，依然是自动去重

使用remove(key)去除key元素，key不存在时会报错。

s={'A', 'C', 'B'}

s.add('D')

s.add('A')

s.remove('C')

print(s) #{'A', 'D', 'B'}

函数

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

return None可以简写为return

def my_sum(x,y):

    return x+y

print(my_sum(3,5))  #8

函数返回多值（实际上就是返回一个tuple）

def my_sum(x,y):

    return x,y,x+y

print(my_sum(3,5))  #(3, 5, 8)

python之递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

要找到规律，然后注意结束递归的条件。

def my_def(n):

    n = int(n);

    if n<=0:

        return

    if n==1:

        return 1

    else:

        return n*my_def(n-1)

print(my_def(3)) # 3*2*1 = 6

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

函数的默认参数

函数的参数可以设置默认参数，放在参数列表后面。比如def hanshu(x,y=2,z=3)这种

与php中一样。

Python中的int()函数的第二个参数，就是参数一对应的进制，默认10进制。

不合法会报错，最终返回十进制整数。

print(int('123'))#123

print(int('123',8)) #83

print(int('1010',2)) #10

可变参数

如果想让一个函数能接受任意个参数，我们就可以定义一个可变参数：

Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量args看成一个tuple就好了。

Args只是个变量名，你爱用a,b,c什么都行。

对list和tuple进行切片

切片Slice操作符。以list为例，tuple也是一样的，就是切片完的返回值为元组tuple就是了

L = ['Adam', 'Lisa', 'Bart', 'Paul']

print(L[0:3])   #切片，从索引0开始切3个元素['Adam', 'Lisa', 'Bart']

print(L[:2])   # ['Adam', 'Lisa']如果第一个索引是0，可以省略

print(L[:])   # ['Adam', 'Lisa', 'Bart', 'Paul']只用一个:，表示从头到尾

print(L[::2])   # ['Adam', 'Bart']还可以给第三个参数，表示每N个取第一个

调用方法：变量名[参数]

可填3个参数，参数使用:间隔。

我的理解：第一个起始索引默认0，第二个切分的个数默认为len(变量)就是切到末尾，第三个参数默认为1。至少需要一个:

倒序切片，切片同样支持负数索引：

print(L[-3:2])   # ['Lisa']

print(L[-4:-1:3])   # ['Adam']

记住倒数第一个元素的索引是-1。

切片包含起始索引，不包含结束索引。

字符串也可以切片：字符串的索引同样从0开始，且支持负索引。

然后切片只能正着切，不能逆着切。

print('ABCDEFG'[-3:-1]) #EF

print('ABCDEFG'[-3:2]) #空 因为索引2的位置比索引-3的位置靠前。

print('ABCDEFG'[-3:4]) #空 位置重叠也是不行的。

Python中的集合

集合是指包含一组元素的数据结构，目前接触到的包括：

1.有序集合：list，tuple，字符串；

2.无序集合：set

3.无序集合并且具有key-value 对：dict

索引迭代

Python中，迭代永远是取出元素本身，而非元素的索引。

对于有序集合，元素确实是有索引的。有的时候，我们确实想在for 循环中拿到索引。

方法是使用enumerate() 函数：enumerate(枚举)

L = ['Adam', 'Lisa', 'Bart', 'Paul']

for index, name in enumerate(L):

    print(index, '-', name)

#index即为索引，name为其值

生成列表

使用range()函数

>>> range(1, 11)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Python还有一种特有的语法糖：列表生成式

例：生成[1x1, 2x2, 3x3, ..., 10x10]的列表

[x * x  for  x  in  range(1, 11)]

多写写应该就熟悉了。

range(1, 100, 2) 可以生成list [1, 3, 5, 7, 9,...,99]

格式化字符串

字符串可以通过%进行格式化，用指定的参数替代%s。字符串的join()方法可以把一个list 拼接成一个字符串。

def generate_tr(name, score):

    return '我是：%s，我考了%s分' % (name, score)

print(generate_tr('菜鸟',98)) #我是：菜鸟，我考了98分

列表生成式中还可以加入条件过滤

在for 循环后面还可以加上 if 判断

>>>[x * x  for  x  in  range(1, 11)  if  x  % 2 == 0]

[4, 16, 36, 64, 100]

多层表达式

for循环可以嵌套，因此，在列表生成式中，也可以用多层for循环来生成列表。

对于字符串'ABC' 和 '123'，可以使用两层循环，生成全排列：

>>> [m + n  for  m  in  'ABC'   for  n  in   '123']

['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

翻译成循环代码就像下面这样：

L = []

for m in 'ABC':

    for n in '123':

        L.append(m + n)

python中列表生成式使用的经典例子

一行代码实现乘法口诀表：

print ('\n'.join([' '.join(['%s*%s=%-2s' % (y,x,x*y) for y in range(1,x+1)]) for x in range(1,10)]))

666666