Python学习笔记：入坑第一步

一、python 基础 1、数学操作符，优先级从高到低

操作符	操作	例子	求值为
**	指数	2**3	8
%	取模/求余数	22%8	6
//	整除/商数取整	22//8	2
/	除法	22/8	2.75
*	乘法	3*5	15
-	减法	5-2	3
+	加法	2+2	4

可以使用括号来改变通常的优先级。 2、常见的数据类型

数据类型	例子
整型	-2，-1，0，1，2，3，4，5，6
浮点型	-1.25，-1.0，-0.5，0.0，0.5，1.0，1.25
字符串	‘a’ , ‘aa’ , ‘aaa’ , ‘Hello！’ ，‘11 cats’,’’

字符串可以为空字符串即：’’ 3、字符串的连接和复制 字符串的连接：+

>>> '我好帅'+'太帅了'
'我好帅太帅了'

​ 字符串连接只能是：字符串 + 字符串 ；否则报错。

字符串的复制：*

>>> '程序员都是最靓的仔；' * 2
'程序员都是最靓的仔；程序员都是最靓的仔；'

​ 字符串的复制只能是：字符串 * 整型 ；否则报错。

4、变量

>>> A=123
>>> A
123
>>> a='456'
>>> a
'456'
>>> A=a
>>> A
'456'
>>> a
'456'
>>> A=789
>>> A
789

如果变量被赋了一个新值，老值就会被忘记。

变量名的要求：

​ 1、只能是一个词

​ 2、只能包含字母、数字和下划线。

​ 3、不能以数字开头

变量名区分大小写；变量用小写字母开头是Python的惯例。 5、增强的赋值操作符

增强的赋值语句	等价的赋值操作符
A +=1	A=A+1
A -=1	A=A-1
A *=1	A=A*1
A /=1	A=A/1
A%=1	A=A%1

6、第一个python程序 如果要编写完整的python程序，就需要在文件编辑器中输入指令。 文件编辑器窗口没有>>>提示符。

#请输入你想说的话
print('请输入你想对自己说的话：')
talk=input()
print('这是你想对自己说的话：'+talk)
print('这是你说话的长度')
print(len(talk))
print('将整型类型转化为字符串类型：')
str2=str(len(talk))
str3='只有字符串和字符换相加才不会报错：'+str2
print(str3)
print('将字符串类型转化为浮点类型')
float2=float(str2)
print(float2)
print ('将浮点类型转化为整数类型')
int2=int(float2)
print(int2)

运行结果如图：

7、程序解析 注释：

#请输入你想说的话

print()函数：

print('请输入你想对自己说的话：')

input函数：

talk=input()

input()函数等待用户在键盘上输入一些文本，并按下回车键。 len()函数

print('这是你说话的长度')
print(len(talk))

len()函数中传递一个字符串（或包含字符串的变量），求出字符串中字符的个数，返回的值为整型。 str()、int()和float函数：

运算	结果
str(0)	‘0’
str(-2.34)	‘-2.34’
int (‘42’)	42
int (’-42’)	-42
int (’-2.34’)	报错！！！！
int (-2.34)	-2
float(10)	10.0
float(’-2.34’)	-2.34

字符串、整型、浮点之间的相等判断：

判断	结果
1 == 1.0	True
1 == ‘1.0’	False
1.0 == 001.0	True
1.0 == ‘1.0’	False

二、控制流 1、布尔值

“布尔“类型只有两种值：True 和 False

要求：首字母：T,F必须大写 2、比较操作符

符号	名称
==	等于
！=	不等于
<	小于
>	大于
<=	小于等于
>=	大于等于

”==“，”！=“操作符实际上可以用于所有的数据类型的值。 ”<“，”>“，”“，”<=“，”>=“操作符仅用于整型和浮点型值。 3、布尔操作符 二元布尔操作符：and;or

and操作符的真值表

表达式	结果
True and True	True
True and False	False
False and True	False
False and False	False

or操作符的真值表

表达式	结果
True or True	True
True or False	True
False or True	True
False or False	False

一元布尔操作符：not

not操作符的真值表

表达式	结果
not True	False
not False	True

4、混合布尔和比较操作符

>>> (4<5)and (5<6)
True

5、控制流的元素 条件：

​ 控制流语句根据条件是True还是False，来决定做什么。

代码块：

​ 一些代码行可以作为一组，放在”代码块“中。可以根据代码行的缩进，知道代码块的开始和结束。代码块有三条规则：

​ 1、缩进增加时，代码块开始。

​ 2、代码块可以包含其他代码块。

​ 3、缩进减少为零，或减少为外面包围代码块的缩进，代码块就结束了。

6、控制流语句 1）if语句：

name='帅哥'
if name =='帅哥':
    print('你好帅哥！')

结果：

if语句包含以下部分;

if  条件:
	缩进的代码行（if子句）

2）else 语句

name='美女'
if name =='帅哥':
    print('你好帅哥！')
else:
    print('你好美女！')

结果：

else语句包含以下部分

else:
	缩进的代码块（else子句）

3）elif语句

name='小猫'
if name =='帅哥':
    print('你好帅哥！')
elif name=='小猫':
    print('小猫好可爱')

结果：

elif语句包含以下部分

elif 条件:
	缩进的代码块（elif子句）

4）while循环语句

i=0
while i<5:
    print(i)
    i=i+1

结果：

while语句包含以下部分

while 条件:
	缩进的代码行（while子句）

5）break语句

如果遇到break语句，就会马上退出while循环子句

i=0
while i<5:
    print(i)
    if i==2:
        break
    i=i+1
print('i为2，证明跳出循环，i的值为：'+str(i))

结果：

6）continue语句

如果程序执行遇到continue语句，就会马上跳回到循环开始处，重新进行下一次循环

i=0
while i<5:
    i=i+1
    if i==2:
        continue
    print(i)

结果：

7）for循环和range()函数

for i in range(5):
    print(i)

注意： 这里的 i 不需要赋值

结果：

for语句包含以下部分

for 变量 in range(参数1):                                //range()方法最多传入3个参数
	缩进的代码行（for子句）

8）range的三个参数：开始、停止、步长 range（开始值，停止值）

for i in range(5,9):
    print(i)

结果：

range(开始值，停止值，步长值)

for i in range(1,10,2):
    print(i)

结果：

9）sys.exit()提前结束程序

import sys
while True:
    print ('请输入任意字符串，输入exit将结束循环：')
    response=input()
    if response=='exit':
        sys.exit()
    print('你输出的字符串为'+response)

结果：

10)导入模块

import sys,random
while True:
    num=random.randint(1,10)
    print (num)
    if num==6:
        sys.exit()
    print('随机产生的整数为'+str(num))

结果：

from import 语句

import random 相当于 from random import *

注意：

while True:
	print('程序陷入无限循环！')

此时请按Ctrl+C 停止程序 三、函数 1、def语句和参数

def hello(name):
    print('Hello'+name)
hello('帅哥')

结果：

def语句和参数包含以下几部分

def 函数名（参数）:
	函数体（函数内操作）

2、返回值和return语句

def getanswer(num):
    if num==1:
        return 'this is one '
    elif num==2:
        return 'this is two'
answer=getanswer(2)
print(answer)

结果：

3、None值 None中的N必须大写

对于所有没有return语句的函数定义，Python都会在末尾加上return None。这类似于while或for循环隐式地以continue语句结尾。同时不带返回值的return语句，也是返回None。

>>> None==print('这是空指')
这是空指
True
>>> 

4、关键子参数和print() 1)python换行符：rn 如图：

2）print(）函数中：end关键字

print('你好')
print('帅哥')
print('-------------------')
print('你好',end='')
print('帅哥')
print('--------------------')
print('你好',end=':大家都是')
print('帅哥')

结果：

解析：

前两行字符串出现在独立的两行里，是因为：print()函数自动在传入的字符串末尾添加了换行符。
当设置了end关键字参数，print()函数就会自动在传入的字符串末尾添加该end关键字参数值。

3）print()函数中：sep关键字

print('帅哥','美女','小可爱')
print('-----------------')
print('帅哥','美女','小可爱',sep='和')
print('-----------------')
print('帅哥','美女','小可爱',sep='rn')

结果：

解析：

第一行：当想print()传入多个字符串值，该函数回自动调用一个空格分隔多个字符串值。
当传入sep关键字参数，替换掉默认的分隔字符串，此时函数调用传入的sep关键字参数值分隔多个字符串值。

5、局部和全局作用域 1）局部变量不能再全局作用域中内使用 2）局部作用域不能使用其他局部作用域内的变量 3）全局变量可以在局部作用域中读取：局部变量没有此变量名，单全局有此变量名。 4）名称相同的局部变量和全局变量

def A():
    name='帅哥'
    print(name)
def B():
    name='美女'
    print(name)
name='小可爱'
A()
print(name)

结果：

6、global语句

def A():
    global name
    name='帅哥'
    print(name)
def B():
    name='美女'
    print(name)
name='小可爱'
A()
B()
print(name)

结果：

7、异常处理 举例：获取一个除数为0的错误，但不影响程序的执行

此时使用：try和except语句来处理

def divide(num):
    try:
        return 12/num
    except ZeroDivisionError:
        return 'num作为除数，不能为0'
print(divide(1))
print(divide(2))
print(divide(0))
print(divide(-2))
print(divide(-1))

结果：

四、列表 1、列表简介 1)举例：

L=['表项1','表项2','表项3','表项4']

2）空列表

[]

3）列表的正数下标

L=['a','b','c']

其列表对应的下标为：L[0],L[1],L[2] 注意：

​ 下标的值不能大于或等于列表中值的个数，否则报错：IndexError。

​ 下标的值只能是整数，不能是浮点数，否则报错：TypeError。

>>> L=['a','b','c']
>>> L[0]
'a'
>>> L[3]
Traceback (most recent call last):
  File "", line 1, in 
    L[3]
IndexError: list index out of range
>>> L[2.5]
Traceback (most recent call last):
  File "", line 1, in 
    L[2.5]
TypeError: list indices must be integers, not float
>>> 

4）列表的负数下标

>>> L=['a','b','c']
>>> L[-1]
'c'
>>> L[-2]
'b'
>>> L[-3]
'a'
>>> L[-4]
Traceback (most recent call last):
  File "", line 1, in 
    L[-4]
IndexError: list index out of range

注意：

​ 负数下标从-1开始，-1指的是列表的最后一个下标，以此类推；

​ 负数下标的绝对值不能大于列表中值的个数，否则报错：IndexError。

5）利用切片’ : '取得子列表

>>> L=['a','b','c']
>>> L[0:3]
['a', 'b', 'c']
>>> L[0:2]
['a', 'b']
>>> L[0:]
['a', 'b', 'c']
>>> L[:3]
['a', 'b', 'c']
>>> L[-2:]
['b', 'c']
>>> L[-2:3]
['b', 'c']
>>> L[:]
['a', 'b', 'c']

注意：

​ L[A:B]：从A下标开始（包括A下标），截至B下标结束（不包括B下标）。

​ L[A:]: 从A下标开始（包括A下标），截至列表的长度值结束。

​ L[:B]: 从下标0开始（包括0下标），截至B下标结束（不包括B下标）。

​ L[:]: 从下标0开始（包括0下标），截至列表的长度值结束。

6）获取列表的长度 len()

>>> L=['a','b','c']
>>> len(L)
3

7）使用下标改变列表中的值

>>> L=['a','b','c']
>>> L
['a', 'b', 'c']
>>> L[0]=1
>>> L[1]=2
>>> L[2]=3
>>> L
[1, 2, 3]
>>> 

8）列表的连接’ + ‘和复制’ * ’

>>> L=['A','B']
>>> H=['1','2']
>>> L*2
['A', 'B', 'A', 'B']
>>> L=L+H
>>> L
['A', 'B', '1', '2']
>>> H
['1', '2']
>>> H=H*2
>>> H
['1', '2', '1', '2']

9）从列表中删除值

>>> L=['1','2','3','4','5','6']
>>> L
['1', '2', '3', '4', '5', '6']
>>> del L[5]
>>> L
['1', '2', '3', '4', '5']
>>> del L[2:]
>>> L
['1', '2']

10）列表可以跨越多行，且这些行的缩进不重要，没有结束方括号，列表就没有结束

>>> L=[
	12,'123',
'帅哥',
	'美女',
	]
>>> L
[12, '123', '帅哥', '美女']

2、列表的使用 1)列表用于循环

for i in [0,1,3,5]:
    print(i)
    

2）in 和not in操作符

>>> L=['a','b','c']
>>> 'a' in L
True
>>> 'd' in L
False
>>> 'd' not in L
True
>>> 

3)多重赋值 使用一行代码，用列表中的值为多个变量赋值

>>> L=['小明','帅哥','23']
>>> name,remark,age=L
>>> name
'小明'
>>> remark
'帅哥'
>>> age
'23'

注意：变量的数目和列表的长度必须严格相等，否则报错：ValueError。 4)增强的操作符

>>> L=['a','b']
>>> L
['a', 'b']
>>> L+='c'
>>> L
['a', 'b', 'c']
>>> L*=2
>>> L
['a', 'b', 'c', 'a', 'b', 'c']

注意：+=操作符此时用于列表的连接，*=操作符完成列表的复制 3、列表的方法 1）index()方法：查找列表值中对应的下标

>>> L=['a','b','b']
>>> L.index('a')
0
>>> L.index('b')
1
>>> L.index('c')
Traceback (most recent call last):
  File "", line 1, in 
    L.index('c')
ValueError: 'c' is not in list

注意：使用index(A) 方法时：

​ 如果A不在列表中，则报错：ValueError

​ 如果A在列表中重复，则方法返回A第一次出现在列表中的下标。

2）append()方法：将参数添加到列表末尾

>>> L=['A','B','C']
>>> L
['A', 'B', 'C']
>>> L.append('D')
>>> L
['A', 'B', 'C', 'D']

3）insert()方法：在列表的任意下标处插入一个值

>>> L=['a','b','c']
>>> L
['a', 'b', 'c']
>>> L.insert(1,'*')
>>> L
['a', '*', 'b', 'c']

注意：insert(参数1，参数2)方法中，参数1是新值的下标，参数2是要插入的新值 4）remove()方法：从列表中删除值

>>> L=['a','b','c']
>>> L
['a', 'b', 'c']
>>> L.insert(1,'*')
>>> L
['a', '*', 'b', 'c']
>>> L=['a','b','c']
>>> L
['a', 'b', 'c']
>>> L.remove('a')
>>> L
['b', 'c']

注意： 给remove传入的是一个值； 试图删除列表中不存在的值，将导致ValueError错误。 如果该值在列表中出现多次，只有第一次出现的值会被删除。 如果知道删除值在列表中的下标，使用：del语句 5）sort()方法将列表中的值排序 sort()默认排序

>>> L=['a','f','c']
>>> L.sort()
>>> L
['a', 'c', 'f']
>>> L=['3','5.5','2']
>>> L.sort()
>>> L
['2', '3', '5.5']
>>> L=[1,2,0,'d','adf','c']
>>> L.sort()
Traceback (most recent call last):
  File "", line 1, in 
    L.sort()
TypeError: unorderable types: str() < int()

注意： sort()方法当场对列表排序，千万不要写成 L=L.sort() 这样的代码，来试图记录返回值。 sort()方法不能对机油数字，又有字符串值的列表排序，否则会报错：TypeError。 sort()方法对字符串排序时，默认使用‘ASCIl字符顺序’，并非实际的字典顺序。 sort()方法按逆序排序

>>> L=['a','b','c']
>>> L.sort(reverse=True)
>>> L
['c', 'b', 'a']

sort()方法按普通字典顺序排序

>>> L=['C','a','A']
>>> L.sort(key=str.lower)
>>> L
['a', 'A', 'C']

4、类似列表的类型：字符串和元组 1）字符串和列表的区别

相同点：按下标取值，切片，for循环，len()，in，not in，多重赋值，增强操作符，index()方法

不同点：字符串没有append()，insert()，remove()，sort()方法，无法利用下标改变字符串的值。

2）元组数据类型和列表的区别 同上字符串与列表的区别：

相同点：按下标取值，切片，for循环，len()，in，not in，多重赋值，增强操作符，index()方法

不同点：字符串没有append()，insert()，remove()，sort()方法，无法利用下标改变字符串的值。

注意：如果元组中只有一个值，你可以在括号内该值的后面跟上一个逗号，表明这种

情况。否则，Python 将认为，你只是在一个普通括号内输入了一个值。

>>> type(('1'))

>>> type(('1',))

3）list()和tuple()转换类型 字符串转列表举例：list()

>>> L='abcdef'
>>> list(L)
['a', 'b', 'c', 'd', 'e', 'f']
>>> L
'abcdef'
>>> L=list(L)
>>> L
['a', 'b', 'c', 'd', 'e', 'f']

元组转列表举例：list()

>>> L=('1','2','3')
>>> list(L)
['1', '2', '3']
>>> L
('1', '2', '3')
>>> L=list(L)
>>> L
['1', '2', '3']

字符串转元组举例：tuple()

>>> y='1234'
>>> tuple(y)
('1', '2', '3', '4')
>>> y
'1234'
>>> y=tuple(y)
>>> y
('1', '2', '3', '4')

列表转元组举例：tuple()

>>> y=[1]
>>> tuple(y)
(1,)
>>> y
[1]
>>> y=tuple(y)
>>> y
(1,)

5、引用

>>> L=['a','b','c']
>>> L
['a', 'b', 'c']
>>> A=L
>>> A
['a', 'b', 'c']
>>> L[0]='1'
>>> L
['1', 'b', 'c']
>>> A
['1', 'b', 'c']
>>> A[0]='2'
>>> A
['2', 'b', 'c']
>>> L
['2', 'b', 'c']

可以理解为：把集合看成一个箱子，箱子里装了‘a’，‘b’，‘c’ 三个球，并给箱子贴上了L便签，后来又给箱子贴上了A便签，无论怎样操纵箱子里的小球，箱子里小球都会随之变化。 1)copy模块中的copy()函数

>>> import copy
>>> L=['o','o',['o','o']]
>>> L
['o', 'o', ['o', 'o']]
>>> H=copy.copy(L)
>>> H
['o', 'o', ['o', 'o']]
>>> H[0]='x'
>>> H
['x', 'o', ['o', 'o']]
>>> L
['o', 'o', ['o', 'o']]#注意H变化前后L的值
>>> H[2][0]='x'
>>> H
['x', 'o', ['x', 'o']]
>>> L
['o', 'o', ['x', 'o']]#注意H边话前后L的值

2）copy模块中deepcopy()函数

>>> import copy
>>> L=['o','o',['o','o']]
>>> L
['o', 'o', ['o', 'o']]
>>> H=copy.deepcopy(L)
>>> H
['o', 'o', ['o', 'o']]
>>> H[0]='x'
>>> H
['x', 'o', ['o', 'o']]
>>> L
['o', 'o', ['o', 'o']]#注意H变化前后L的值
>>> H[2][0]='x'
>>> H
['x', 'o', ['x', 'o']]
>>> L
['o', 'o', ['o', 'o']]#注意H变化前后L的值
>>>

对比 1） 2）可知，deepcopy() 函数同时会复制列表内部的列表。