Python学习笔记：入坑第一步

Python学习笔记：入坑第一步 一、python 基础 1、数学 *** 作符，优先级从高到低 *** 作符 *** 作例子求值为**指数2**38%取模/求余数22%86//整除/商数取整22//82/除法22/82.75*乘法3*515-减法5-23+加法2+24 可以使用括号来改变通常的优先级。 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 +=1A=A+1A -=1A=A-1A *=1A=A*1A /=1A=A/1A%=1A=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’)42int (’-42’)-42int (’-2.34’)报错！！！！int (-2.34)-2float(10)10.0float(’-2.34’)-2.34 字符串、整型、浮点之间的相等判断： 判断结果1 == 1.0True1 == ‘1.0’False1.0 == 001.0True1.0 == ‘1.0’False 二、控制流 1、布尔值

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

要求：首字母：T,F必须大写 2、比较 *** 作符 符号名称==等于！=不等于<小于>大于<=小于等于>=大于等于 ”==“，”！=“ *** 作符实际上可以用于所有的数据类型的值。 ”<“，”>“，”“，”<=“，”>=“ *** 作符仅用于整型和浮点型值。 3、布尔 *** 作符 二元布尔 *** 作符：and;or

and *** 作符的真值表

表达式结果True and TrueTrueTrue and FalseFalseFalse and TrueFalseFalse and FalseFalse

or *** 作符的真值表

表达式结果True or TrueTrueTrue or FalseTrueFalse or TrueTrueFalse or FalseFalse 一元布尔 *** 作符：not

not *** 作符的真值表

表达式结果not TrueFalsenot FalseTrue 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() 函数同时会复制列表内部的列表。