Python学习笔记(上)

Part 1

print()函数的使用

一、 可以输出哪些内容？

1. 可以是数字
2. 可以是字符串
3. 可以是含有运算符的表达式

#输出数字
print(520)
#输出字符串
print('helloworld')
#输出含运算符的表达式(输出结果：4)
print(3+1)

二、可以将输出内容输出的目的地

1. 显示器
2. 文件

#将文件输出到文件
fp=open('D:/text.txt','a+')
#a+:打开一个文件用于读写。若文件存在，文件指针放在文件结尾；若不存在，创建新文件用于读写
#将hello world输入到fb文件
print('hello world',file=fp)
#关闭文件
fp.close()

#注意：1、指定盘符要存在；2、使用file=fp

三、输出形式

1. 换行
2. 不换行

#print() 就是换行输出

#不进行换行输出(输出内容在一行)
print('hello','world','Python')
#输出结果：hello world Python

转义字符与原字符

一、什么是转义字符
反斜杠+想要转义功能首字母

二、为什么需要转义字符?

1. 当字符串中包含反斜杠、单引号和双引号等有特殊用途的字符时，必须使用反斜杠对这些字符进行转义(转换一个含义)。

反斜杠: \\
单引号: \'
双引号: \"

2. 当字符串中包含换行、回车，水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符当字符串中包含换行。

换行:\n
回车:\r
水平制表符:\t
退格:\b

print('hello\tworld')
输出：hello   world   
中间三个空格，每四个字符一个制表位

print('helloooo\tworld')
输出：helloooo    world   
中间四个空格，每四个字符一个制表位，若前面字符都占满制表位，重开一个制表位

print('hello\rworld')
输出：world 
先输出hello，回车后光标移动到开头，然后输出world  

print('hello\bworld')
输出：hellworld 
o字母被回退

print('http:\\\\www.baidu.com')
输出：http:\\www.baidu.com

3. 原字符：不希望字符串中的转义字符起作用，就使用原字符，就是在字符串之前加上r,或R

print(r'hello\nworld')
输出：hello\nworld
注意：最后一个字符不能是一个反斜杠(两个可以)

二进制与字符编码

一、Python中的标识符与保留字

1. 保留字：有一些单词被我赋予了特定的意义，这些单词你在给你的任何对象起名字的时候都不能用

import keyword
print(keyword.kwlist)
输出：
['False', 'None', 'True', 'and', 'as', 
'assert', 'async', 'await', 'break', 'class',
 'continue', 'def', 'del', 'elif', 'else', 
 'except', 'finally', 'for', 'from', 'global',
  'if', 'import', 'in', 'is', 'lambda', 
  'nonlocal', 'not', 'or', 'pass', 'raise', 
  'return', 'try', 'while', 'with', 'yield']

2. 标识符：变量、函数、类、模块和其它对象的起的名字就叫标识符

二、Python中的变量与数据类型

1. 变量是内存中一个带标签的盒子
   

2. 变量由三部分构成
   标识：对象存储的内存地址；使用函数id(obj)获取。
   类型：对象数据类型；使用函数type(obj)获取。
   值：对象存储的具体数据，使用print(obj)将值打印输出
   name中存储一个单元地址，指向该对象的组成部分

3. 多次赋值后，变量会指向新的空间
   

4. 数据类型
   整数类型→int →98
   浮点数类型→float →3.14159
   布尔类型→bool →True ,False
   字符串类型→str→’十人生苦短,我用Python’

5. 整数类型(int)
   

print("十进制:",118)
print("二进制:",0b111010)
print("八进制:",0o157)
print("十六进制:",0xABCDE)

输出:
十进制: 118
二进制: 58
八进制: 111
十六进制: 703710

6. 浮点类型(float)
   存储浮点数不精确，会存在误差。
   因为数都是以二进制进行存储的，每一个二进制数都可以由十进制表示，而二进制不能表示所有的十进制数。

n1 = 1.1
n2 = 2.2
print(n1+n2)

输出：3.3000000000000003

解决方案：
导入模块decimal

from decimal import  Decimal
print(Decimal('1.1')+Decimal('2.2'))

输出：3.3

7. 布尔类型(bool)
   布尔值可以转化为整数
   True→1
   False→0

b1 = True
b2 = False
print(b1+1)
print(b2+1)

输出：
2
1

8. 字符串类型(str)
   ●字符串又被称为不可变的字符序列
   ●可以使用单引号、双引号、三引号、或三双引号来定义
   ●单引号和双引号定义的字符串必须在一行
   ●三引号定义的字符串可以分布在连续的多行

str1 = '人生苦短，我用Python'
str2 = "人生苦短，我用Python"
str3 = """人生苦短，
我用Python"""
str4 = '''人生苦短，
我用Python'''
#三引号、三双引号可以跨行转换
print(str1,type(str1))
print(str2,type(str2))
print(str3,type(str3))
print(str4,type(str4))

输出：
人生苦短，我用Python <class 'str'>
人生苦短，我用Python <class 'str'>
人生苦短，
我用Python <class 'str'>
人生苦短，
我用Python <class 'str'>

9. 数据类型转换
   

name = '张三'
age = 20
print('我叫'+name+'今年'+age+'岁')
#当str类型与int类型进行连接时，报错
#解决方案:类型转换
print('我叫'+name+'今年'+str(age)+'岁')
#将int通过str()函数转成了str类型


str1 = '76.77'
print(int(str1))
#会报错，因为字符串是小数串
ff = True
print(int(ff))
输出：1

s1 = '76'
print(float(s1))
输出：76.0

三、Python中的注释
单行注释→以"#'开头， 直到换行结束
多行注释→并没有单独的多行注释标记，将一对三引号之间的代码称为多行注释
中文编码声明注释→在文件开头加上中文声明注释，用以指定源码文件的编码格式

#输出功能（单行注释）

'''哈哈哈
(多行注释)
'''

#codeing:utf-8
#作者：XXX
#开发时间:XXX
#中文编码声明注释

Part 2

一、 Python的输入 函数input()

#输入函数
present = intput('请输入字符串')
#用户输入ABC
print(present)
#输出：ABC

#从键盘录入两个整数，计算两个整数的和
a = input('请输入一个加数')
b = input('请输入另一个加数')
print(a+b)
#输入：10    20
#输出：1020----str类型相加，加号起连接作用

改为
#从键盘录入两个整数，计算两个整数的和
a = input('请输入一个加数')
a = int(a)
b = int(input('请输入另一个加数'))
print(a+b)
#输入：10    20
#输出：30

二、Python中 的运算符

1. 算术运算符
   
   

#整除
print(11//2)
输出:5

#幂运算
print(2**3)
输出：8

print(9//4) #输出2
print(-9//-4)#输出2
#一正一负下取整
print(9//-4)#输出-3
print(-9//4)#输出-3

print(9%-4)
#输出：-3
#一正一负要遵循公式： 余数=被除数-除数*商  9-(-4)*(-3)=-3

print(-9%4)
#输出： 3
#一正一负要遵循公式： 余数=被除数-除数*商  -9-(4)*(-3)=3

2. 赋值运算符
   

a=b=c=20;
#链式赋值，a、b、c都指向同一个地址单元
#type=int，value=20，id=同一个地址单元

a,b,c = 20,30,40
print(a,b,c)
#输出 20 30 40

#交换两个变量的值
a,b = 10，20
#交换
a,b = b,a
print(a,b)
输出：20 10

3. 比较运算符
   比较的结果是bool类型
   == 比较的是对象的value值
   比较对象的标识使用 is

a = 10
b = 10
print(a==b) #Ture 说明a和b的value值相等
print(a is b)#Ture 说明a与b的id标识相等
#当a赋值为10，在常量池里存在了10这个常量，后面给b赋值，就是将b指向常量池10的位置，所以id相同

lst1 = [11,22,33,44]
lst2 = [11,22,33,44]
print(lst1==lst2) #比较value True
print(lst1 is list2)#比较id False

5. 布尔运算符
   

#in 可用于判断字母是否在字符串中
s = 'helloworld'
print('w' in s) #w在s里 True
print('k' not in s) #k不在s里 False

7. 位运算符
   

print(4&8)#输出：0
#0000 0100 按位与 0000 1000  ==>0000 0000
print(4|8)#输出：12
#0000 0100 按位或 0000 1000  ==>0000 1100

三、运算符的优先级

算数运算>位运算>比较运算>布尔运算>赋值运算

Part 3

一、程序的组织结构

任何简单或复杂的算法都可以有顺序结构、选择结构和循环结构三种基本结构组合而成

二、对象的布尔值

Python一切皆对象，所有对象都有一个布尔值。获取对象的布尔值，使用内置函数bool()

以下对象的布尔值为False
False、数值0、None、空字符串、空列表、空元组、空字典、空集合

#以下对象bool都为False
print(bool(0))
print(bool(0.0))
print(bool(None))
print(bool(''))#空串
print(bool(""))#空串
print(bool([])) #空列表
print(bool(list())) #空列表
print(bool(())) #空元组
print(bool(tuple())) #空元组
print(bool({})) #空列表
print(bool(dict())) #空字典
print(bool(set())) #空集合

#除以上外都为True

四、分支if结构

1. 单分支if结构
   

money = 1000
s = int(input('请输入取款金额')) #取款金额
#判断余额是否充足
if money>=s:
    money-=s
    print('取款成功，余额为:',money)

2. 双分支if… else结构
   

#从键盘录入一个整数，编写程序让计算机判断是奇数还是偶数
num = int(input('请输入一个整数'))
#条件判断
if num%2==0:
    print(num,'是偶数')
else:
    print(num,'是奇数')

3. 多分支if…elif… else结构
   

#从键盘录入一个分数，编写程序让计算机判断数值范围
score = int(input('请输入一个成绩'))
#条件判断
if score>=90 and score<=100:
    print('A级')
elif 60<=score<=90:
#python可这么写:60<=score<=90
    print('B级')
elif score>=0 and score<=60:
    print('C级')
else :
    print('输入有误')

4. If语句的嵌套
   

#区分会员用户
answer = int(input('你是会员吗'))
money = int(input('请输入你的购物金额'))
#条件判断
if answer == 'y':
    if money>=200:
        print('打八折，付款金额为:',money*0.8)
    elif money>=100:
        print('打九折，付款金额为:',money*0.9)
    else:
        print('不打折，付款金额为:',money)
else :
    if money >= 200:
        print('打9.5折，付款金额为:', money * 0.95)
    else:
        print('不打折，付款金额为:', money)

六、条件表达式

#从键盘录入两个数，比较两个整数的大小
num_a = int(input('请输入第一个整数'))
num_b = int(input('请输入第二个整数'))
#条件表达式比较大小
print((str(num_a)+'大于等于'+str(num_b)) if num_a>=num_b else (str(num_a)+'小于'+str(num_b)))

为True执行左侧内容，为False执行右侧内容

七、pass空语句

1. pass语句：语句什么都不做，只是一个占位符，用在语法上需要语句的地方

#判断是否是会员
answer = int(input('你是会员吗'))
if answer =='y':
    pass #没想好写啥，不会报错
else:
    pass #没想好写啥

2. 什么时候使用: .
   先搭建语法结构，还没想好代码怎么写的时候
3. 哪些语句一起使用
   ●if语句的条件执行体
   ● for-in语句的循环体
   ●定义函数时的函数体

Part 4

一、range()函数的使用

用于生成一个整数序列，返回值是一个迭代器对象

#range()的三种创建方式

#第一种创建方式，只有一个参数
r = range(10) #[0,1,2,3,4,5,6,,8,9] 默认从0开始,步长为1
print(r)#输出:rangr(0,10)
print(list(r))#输出:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#第二种创建方式，给了两个参数
r = range(1,10) #指定了起始值，从1开始，到10结束，(不包含10)，步长为1
print(list(r))#输出:[1, 2, 3, 4, 5, 6, 7, 8, 9]

#第三种创建方式，给了三个参数
r = range(1,10,2) #指定了起始值，从1开始，到10结束，(不包含10)，步长为2
print(list(r))#输出:[1,  3, 5,  7, 9]

二、while循环

a = 1
while a<10:
    a+=1
print(a)#输出:10

#计算0到4之间的累加和
'''
4步循环法
1.初始化变量
2.条件判断
3.条件执行体
4.改变变量
'''
#1.初始化变量
a = 0
sum = 0
#2.条件判断
while a<5:
    #3.条件执行体
    sum+=a
    # 4.改变变量
    a+=1
print('和为',sum)#输出:和为 10

三、for-in循环

可迭代对象:字符串、序列

for item in 'Python':#遍历字符串，遍历的赋值给item
    print(item)

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

#如果在循环体中不需要使用自定义变量，可将自定义变量写为"_"
for _ in range(10):
    print("人生苦短，我用Python")

#输出100到999之间的水仙花数
#水仙花数：153 = 3*3*3+5*5*5+1*1*1
for item in range(100,1000):
    ge = item%10       #个位
    shi = item//10%10  #十位
    bai = item//100%10 #百位
    #判断条件
    if ge**3+shi**3+bai**3==item:
        print(item)
        
输出：
153
370
371
407

四、break、continue 与else语句

1. break
   

#从键盘录入密码，最多录入3次，正确结束循环
for item in range(3):
    pwd = input('请输入密码')
    if(pwd=='888'):
        print('密码正确')
        break;
    else:
        print('密码错误')

2. continue
   

'''
要求输出1-50间的所有5的倍数
'''
for item in range(1,51):
    if item%5 != 0:
        continue;
    print(item)

3. else语句
   

#从键盘录入密码，最多录入3次，正确结束循环
for item in range(3):
    pwd = input('请输入密码')
    if(pwd=='888'):
        print('密码正确')
        break;
    else:
        print('密码错误')
else:
    print('对不起，三次密码均输入错误')
#for/while不break退出后，就执行else语句

五、嵌套循环.

#输出三行四列的矩形
for i in range(1,4):
    for j in range(1,5):
        print('*',end='\t')#不换行输出
    print()#换行


#打印99乘法表
for i in range(1,10):#行
    for j in range(1,i+1):#列
        print(i,'*',j,'=',i*j,end='\t')
    print()

二重循环中的break和continue

Part 5

一、什么是列表

列表就是书包，书包可以装各种东西(装各种类型的数据)

#变量存一个对象的引用，列表存储多个变量的引用
list = ['hello','world',98]
print(id(list))
print(type(list))
print(list)
输出:
1946527891656
<class 'list'>
['hello', 'world', 98]

二、列表的创建与删除

#创建列表第一种方式，使用[]
lst = ['hello','world',98]

#创建列表第一种方式，使用内置函数list()
list = list('hello','world',98)

三、列表的特点

lst = ['hello','world',98]
print(lst[0],lst[-3])
输出:
hello hello

四、列表的查询操作

lst = ['hello','world',98,'hello']
print(lst.index('hello'))
#如果列表中有相同元素只返回列表中相同元素的第一个元素索引
输出:0

print(lst.index('hello',1,4)) 
#从索引1-4(不包括4)去寻找hello
输出:3

lst = ['hello','world',98,'hello']
#获取索引为2的元素
print(lst[2])
输出:98

#获取索引为-3的元素
print(lst[-3])

输出:world

lst = [10,20,30,40,50,60,70,80]
print(lst[1:6:1])
#起始位置为1，结束位置为6(不包含6)，步长为1
输出:
[20, 30, 40, 50, 60]

print(id(lst))
print(id(lst[1:6:1]))
#切出来的是对原列表的拷贝
输出:
3161610223816
3161610223944

print(lst[1:6:])
#默认步长为1
输出:
[20, 30, 40, 50, 60]

print(lst[:6:2])
#省略start，默认从0开始
输出:
[10, 30, 50]

print(lst[1::2])
#省略end，默认切到列表最后一个元素
输出:
[20, 40, 60, 80]

print('原列表',lst)
print(lst[::-1])
#步长为负数
输出:
原列表 [10, 20, 30, 40, 50, 60, 70, 80]
[80, 70, 60, 50, 40, 30, 20, 10]

print(lst[7::-1])
#从0-7(不包含0)的索引开始逆置列表
输出:
[80, 70, 60, 50, 40, 30, 20, 10]

print(lst[6:0:-2])
#从0-6(不包含0)的索引开始以步长为2逆置列表
输出:
[70, 50, 30]

#判断元素是否存在
lst = [10,20,30,40,50,60,70,80]
print(10 in lst)#True
print(90 not in lst)#True

#遍历
for item in lst:
    print(item,end='\t' )

五、列表元素的增、删、改操作

lst = [10,20,30]

#末尾添加100
lst.append(100)
print(lst)
#输出:[10, 20, 30, 100]

lst2 = [40,50]
#列表作为一个元素添加进去了
lst.append(lst2)
print(lst)
#输出:[10, 20, 30, 100, [40, 50]]

#向列表末尾一次性添加多个元素
lst.extend([40,50])
print(lst)
#输出:[10, 20, 30, 100, [40, 50], 40, 50]

#指定位置插入元素
lst.insert(1,90)
print(lst)
#输出:[10, 90, 20, 30, 100, [40, 50], 40, 50]

lst3 = [True,False,'hello']
#1-末尾的切片换成lst3
lst[1:]=lst3
print(lst)
#输出:[10, True, False, 'hello']

lst = [10,20,30,40,50]
lst.remove(30)
#从列表中移除一个元素，如果有重复元素只移除第一个
print(lst)
#输出:[10, 20, 40, 50]

#pop()根据索引删除元素
lst.pop(1)#默认删除最后一个元素
print(lst)
#输出:[10, 40, 50]

#切片操作---至少删除一个元素，将产生一个新的列表元素
new_list = lst[1:3]
print(new_list)

#不产生新的列表元素对象，而是删除原列表中的内容
lst[1:2]=[]
print(lst)

#清楚列表所有元素
lst.clear()

#del语句将列表对象删除,删除后对象不存在
del lst

更新操作

lst = [10,20,30,40,50]

#一次修改一个值
lst[2]=100
#列表索引为2第地址指向value=100对象地址
print(lst)
#输出:[10, 20, 100, 40, 50]

lst[1:3]=[300,400,500,600]
print(lst)
#输出:[10, 300, 400, 500, 600, 40, 50]

六、列表元素的排序

（1）调用sort()方法，默认所有元素按照从大到小顺序排序；若指定reverse=True，进行降序排序

lst = [40,10,20,50,30]

print('排序前的列表',lst,id(lst))
lst.sort()
print('排序后的列表',lst,id(lst))
'''
输出:
排序前的列表 [40, 10, 20, 50, 30] 1986274558344
排序后的列表 [10, 20, 30, 40, 50] 1986274558344
id不变，所以是在原列表上修改的
'''

#逆序排序
lst.sort(reverse=True)
print(lst)
#输出:[50, 40, 30, 20, 10]

（2）调用内置函数sorted()，若指定reverse=True，进行降序排序原列表不发生改变

lst = [40,10,20,50,30]
#调用内置函数sorted()，将产生一个新的列表
new_list = sorted(lst)
print(new_list)
#输出:[10, 20, 30, 40, 50]

desc_list = sorted(lst,reverse=True)
print(desc_list)
#输出:[50, 40, 30, 20, 10]

七、列表推导式

lst = [i*i for i in range(1,10)]
print(lst)
#输出:[1, 4, 9, 16, 25, 36, 49, 64, 81]

Part 6

一、什么是字典

键值对、无序、不可变序列

字典的特点：

二、字典的原理

hash(key) --> value

三、字典的创建

#使用自创建字典
scorce = {'张三':100,'王五':80}
print(scorce,type(scorce))
#输出:{'张三': 100, '王五': 80} <class 'dict'>

#使用dict创建字典
student = dict(name='jack',age=20)
print(student,type(student))
#输出:{'name': 'jack', 'age': 20} <class 'dict'>

四、字典的查询操作

#获取字典元素
scorce = {'张三':100,'王五':80}

#第一种方式，使用[]
print(scorce['张三'])
#输出:100
print(scorce['zhangsan'])
#报错：KeyError: 'zhangsan'

#第二种方式，使用get
print(scorce.get('张三'))
#输出:100
print(scorce.get('zhangsan'))
#输出:None

#获取字典元素
scorce = {'张三':100,'王五':80}

#获取所以key
keys = scorce.keys()
print(keys)
#输出:dict_keys(['张三', '王五'])
print(type(keys))
#输出:<class 'dict_keys'>

#将keys视图转为列表
print(list(keys))
#输出:['张三', '王五']

#获取所有的value
values = scorce.values()
print(values)
#输出:dict_values([100, 80])
print(type(values))
#输出:<class 'dict_values'>

#获取所有的键值对
items = scorce.items()
print(items)
#输出:dict_items([('张三', 100), ('王五', 80)])
print(type(items))
#输出:<class 'dict_items'>

#将items视图转为列表
print(list(items))
#输出:[('张三', 100), ('王五', 80)]-->转换后元素由元组组成

五、字典元素的增、删、改操作

#获取字典元素
scorce = {'张三':100,'王五':80}

#查询key
print('张三' in scorce)
#输出:True
print('张三' not in scorce)
#输出:False

#删除key-value对
del scorce['张三']
print(scorce)
#输出:{'王五': 80}

#新增元素
scorce['陈六']=100
print(scorce)
#输出:{'王五': 80, '陈六': 100}

六、字典元素的遍历

scorce = {'张三':100,'王五':80}

for item in scorce:
    print(item,scorce[item])

'''
输出：
张三 100
王五 80
'''

七、字典生成式

items = ['Fruits','Book','Other']
prices = [96,78]

d = {item.upper():price for item,price in zip(items,prices) }
#item.upper()-->大写
print(d)
#输出:{'FRUITS': 96, 'BOOK': 78}

#元素数量不对等，以少的为基准

Part 7

一、什么是元组

'''不可变序列，列表，字典’'''
lst=[10, 20, 45]
print (id(lst))
#输出:2762055577736
lst. append (300)
print(id(lst))
#输出:2762055577736

#地址不改变


'''不可变序列，字符串，元组’'''
s='hello'
print (id(s))
#输出:2761739427944
s=s+'world'
print(id(s))
#输出:2761738970160

#地址发生改变

t =(10,[20,30],40)

#t[1] = [30]
#报错TypeError: 'tuple' object does not support item assignment

t[1].append(60)
print(t)
#输出:(10, [20, 30, 60], 40)

#既t[1]的id不变

二、元组的创建方式

#第一种方式，用()
t = (98,'hello','world')
print(t)
print(type(t))
'''
输出:
(98, 'hello', 'world')
<class 'tuple'>
'''
#第一种方式，省略()
t0 = 98,'hello','world'
print(t0)
print(type(t0))
'''
输出:
(98, 'hello', 'world')
<class 'tuple'>
'''

#第二种方式，用内置函数tuple()
t1 = tuple((98,'hello','world'))
print(t1)
print(type(t1))
'''
输出:
(98, 'hello', 'world')
<class 'tuple'>
'''

#若只含有一个数据类型，要加,
t2 = ('hello')
print(t2)
print(type(t2))
'''
输出:
hello
<class 'str'>
'''

t2 = ('hello',)
print(t2)
print(type(t2))
'''
输出:
('hello',)
<class 'tuple'>
'''

#空元组的创建
t4 = ()
t5 = tuple()

三、元组的遍历

t =(10,[20,30],40)

for item in t:
    print(item)
'''输出:
10
[20, 30]
40
'''