Python学习笔记

Python学习第一天

DAY1:

1.1    基础知识

1、print输出函数

# print函数
# 输出数字
print(520)
print(98.5)

# 输出字符串
print('hello')
print("hello")

# 输出含有运算符的表达式
print(1+2)

# 将数据输出到文件中  注意点:使用file=fp
fp = open('D:/text.txt', 'a+')  # 如果文件不存在就创建,存在就在文件的内容后面继续追加
print('helloworld', file=fp)
fp.close()

# 不进行换行输出
print('hello', 'world', 'Python')

2、转义字符与原字符

# 转义字符
print('hello\nworld')  # 换行
print('hello\tworld')  # TAB
print('helloooo\tworld')
print('hello\rworld')  # 覆盖 world
print('hello\bworld')  # 退一个格子 hellworld

# 原字符:不希望字符串的转义字符起作用,就使用原字符,就是在字符串之前加上r,或者R
print(r'hello\nworld')
# 注意事项,最后一个字符串不能是反斜杠

1.2 变量

# 变量的定义和使用
name='玛利亚'
print('标识',id (name))   # 标识 2188804497008
print('类型',type(name))  # 类型 <class 'str'>
print('值',name)          # 值 玛利亚
# 变量多次赋值,指向新的空间
name='玛利亚'
name='褚柳兵'
print(name)

1.3 注释

 

1.4 数据类型

1、整型:int~~可表示二进制、十进制、八进制、十六进制,默认十进制

二进制0b

八进制0o

十六进制0x

2、浮点类型:float~~解决精度问题

#解决精度问题
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))

3、布尔类型:可以转成整数类型参与计算

#布尔类型:可以转成整数计算
print(True+1)     # 2
print(False+1)    # 1

4、字符串类型:可使用单引号,双引号,三引号,其中三引号可实现换行

1.5 类型转换

# str()将其他类型转换为str类型

# int()将其他类型转换为int类型
# 将str字符串只能是整数数字串,不能是小数串,非数字串
# 将float类型转换为int,会截取摄取

# float()将其他类型转换为float类型
# 字符串中的数据如果是非字符串则不能进行转换

1.6 input函数

# input输入函数 输入的数据为字符串类型
a =int(input('请输入一个加数:'))
b =int(input('请输入另一个加数:'))
print('结果为'+str(a+b))

1.7 运算符

1、算术运算符

# 算术运算符
# 加法:+ 减法:- 乘法:* 除法:/ 整除://
print(11/5)    #2.2
print(11//5)   #2
print(9//-4)   #-3
print(-9//4)   #-3  一正一负整数公式,向下取整
# 取余:%
# 幂运算:**
print(2**3)    #8

2、赋值运算符

# 赋值运算符
# 链式赋值
a=b=c=20
print(a,id(a)) # 20 140725320534272
print(b,id(b)) # 20 140725320534272
print(c,id(c)) # 20 140725320534272
# 参数赋值
# += -= *= /= //= %=
# 支持系列解包赋值
a,b,c=20,30,40  #左右两边数目相等
print(a,b,c)    #20,30,40
# 可用作数字交换
a,b=10,20      #a=10 b=20
print('交换前:',a,b)
a,b=b,a        #a=20 b=10
print('交换后:',a,b)

3、比较运算符~~输出结果为布尔类型

# >,<,>=,<=,!=
# ==比较值
# is,is not比较标识id

4、布尔运算符

# and~~并且    当两个运算数都为True时,结果为True
# or~~或者     当只有一个运算数都为True时,结果为True
# not~~非      当运算数都为True时,结果为False
# in           是否在其中间
print('w' in 'hellowprld')   #True
# not in

5、位运算符  >>,<< -> & -> I

# 位与&         对应位数都是1,结果位数才位1,否则为0
# 位或|         对应位数都是0,结果位数才位0,否则为1
# 左移位运算符<<  高位溢出舍弃,低位补0
# 右移位运算符>>  低位溢出舍弃,高位补0

6、运算符优先级

算术运算->位运算->比较远算符->布尔运算->赋值运算

 

 

 

DAY2

2.1 程序的组织结构

1、顺序结构

2、选择结构

(1)对象的布尔值:Python一切皆对象,所有对象都有一个布尔值,使用bool()函数获取

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

 

(2)分支结构

# 分支结构
#单分支结构
money=1000
s=int(input('请你输入你要取的钱:'))
if money>=s :
    print('取钱成功')

#双分支结构
a=int(input('请你从键盘输入一个整数:'))
if a%2 :
    print('这个数是奇数')
else :
    print('这个数是偶数')

#多分支结构
score=int(input('请输入一个成绩'))
if    90 <= score <= 100 : #PY独有写法
    print('A级')
elif  80 <= score <= 89 :
    print('B级')
elif  70 <= score <= 79:
    print('C级')
elif score >= 60 and score <= 69:
    print('D级')
elif score >= 0 and score <= 59:
    print('E级')
else :
    print('对不起,成绩有误,不在成绩的有效范围')

(3)条件表达式

 

(4)pass语句

# pass语句,什么都不做,只是一个占位符,用到需要写语句的地方
answer=input('您是会员吗?y/n')

#判断是否是会员
if answer=='y' :
    pass
else :
    pass

3、循环结构

(1)range函数

# range()的三种创建方式
# 第一种方式,只有一个参数,步长为1,默认从0开始,到10结束(不包含10)
r=range(10)
print(r)                 #range(0, 10)
print(list(r))           #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#第二种方式,给了两个参数,步长为1,指定从1开始,到10结束(不包含10)
r=range(1,10)
print(r)                 #range(1, 10)
print(list(r))           #[1, 2, 3, 4, 5, 6, 7, 8, 9]

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

#判断指定的整数在序列中是否存在 in,not in
print(10 in r)           #False
print(9 in r)            #True

print(10 not in r)       #True
print(9 not in r)        #False

(2)while循环

# while 循环
'''初始化变量'''
a=0
'''条件判断'''
while a<=10 :
    '''条件执行体(循环体)'''
    print(a)
    '''改变变量'''
    a+=1

(3)for-in循环

# for-in循环
for item in 'Python' :  #第一次取出来的是P,将P赋值给item,将item输出
    print(item)

#range()产生一个整数序列,--》也是一个可迭代对象
for i in range(5) :
    print(i)

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

#计算1-100的偶数和
sum =0
for a in range(0,101,2) :
    sum+=a
print(sum)

(4)else语句

# else语句
# 与if一起使用,如果if条件表达式不成立时执行else
# 与while,for一起使用,如果没有碰到break是执行else
a=0
while a<3 :
    pwd=input('请输入密码')
    if pwd=='8888' :
        print('密码正确')
        break
    else :
        print('密码不正确')
    a+=1
else :
    print('对不起,三次密码均输入错误')

2.2 列表

(1)列表的创建

# 列表的创建
# 方法1:使用[]
lst = ['hello','world',98]
# 方法2;使用list()
lst2 =list(['hello','world',98])
# 列表生成式
lst2=[ i*2 for i in range(1,11)]
print(lst2)   #[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

(2)列表的特点

①列表元素按顺序有序排列

②索引映射唯一数据

③列表可以存储重复数据

④任意数据类型混存

⑤根据需要动态分配和回收内存

(3)获取

# 获取列表索引
lst = ['hello','world',98,'hello']
print(lst.index('hello'))          #如果列表中有相同元素只返回相同元素的第一个   0
print(lst.index('hello',1,4))      #指定查找范围   3

# 获取列表中单个元素
print(lst[2])   #98  正向索引
print(lst[-1])  #hello 逆向索引

# 获取列表中多个元素
lst2=[10,20,30,40,50,60,70,80]
#start=1 ,stop=6, step=1
print(lst2[1:6:1])   #切片出来的是一个新的列表 [20, 30, 40, 50, 60]
#默认步长为1,默认start=0,默认stop为最后
print(lst2[:6:])    #[10, 20, 30, 40, 50, 60]
print(lst2[1::])    #[20, 30, 40, 50, 60, 70, 80]
#step为负数时,第一个元素为原列表的最后一个元素
print(lst2[::-1])   #[80, 70, 60, 50, 40, 30, 20, 10]

(4)查询

①in或者not in

②for-in遍历

(5)增加

①append():在列表末尾添加一个元素

②extend():在列表末尾至少添加一个元素

③insert():在列表任意位置插入一个元素

④切片:在列表任意位置插入至少一个元素

 

(6)删除

# 列表的删除
# remove
lst=[10,20,30,40,50,60,30]
lst.remove(30) #从列表中移除一个元素,若有重复元素,只移除第一个元素
print(lst)     #[10, 20, 40, 50, 60, 30]

# pop 根据索引移除元素,若未指定则删除最后一个元素
lst.pop(1)
print(lst)     #[10, 40, 50, 60, 30]
lst.pop()
print(lst)     #[10, 40, 50, 60]

#切片:删除至少一个元素,但是将产生一个新的列表对象
new_lst=lst[1:3]
print('原列表',lst)             #原列表 [10, 40, 50, 60]
print('切片后的列表',new_lst)    #切片后的列表 [40, 50]

#不产生新的列表,而是删除列表中的内容
lst[1:3]=[]
print('切片后的列表',lst)    #切片后的列表 [10, 60]

# clear 清除列表中所有元素
# del   将列表删除

(7)修改

# 列表的修改
lst=[10,20,30,40,50]
# 一次修改一个值
lst[2]=100
print(lst)   #[10, 20, 100, 40, 50]
# 一次修改多个值
lst[1:3]=[300,400,500]
print(lst)   #[10, 300, 400, 500, 40, 50]

(8)排序

# 列表的排序
# sort ,升序排序
lst=[10,20,40,50,30]
print('排序前的列表',lst,id(lst))  #排序前的列表 [10, 20, 40, 50, 30] 2849276617600
lst.sort()
print('排序后的列表',lst,id(lst))  #升序 排序后的列表 [10, 20, 30, 40, 50] 2849276617600

#通过指定关键字,将列表中的元素进行降序排序
lst.sort(reverse=True)
print('排序后的列表',lst,id(lst))  #降序 排序后的列表 [50, 40, 30, 20, 10] 2849276617600
lst.sort(reverse=False)
print('排序后的列表',lst,id(lst))  #升序 排序后的列表 [10, 20, 30, 40, 50] 2849276617600

# sorted用法和上面差不多,但会产生一个新的列表

 

 

DAY3:

3.1 字典

(1)字典的创建

# 字典的创建
# 方法一
scores={'张三':100,'李四':98,'王五':45}
print(scores)                      #{'张三': 100, '李四': 98, '王五': 45}
print(type(scores))                #<class 'dict'>

#方法二
student=dict(name='jack',age=18)
print(student)                     #{'name': 'jack', 'age': 18}

#空字典
d={}
print(d)                           #{}

d1=dict()
print(d1)                          #{}
#字典生成式    zip过程以元素少的为准
items=['Fruits','Books','Others']
prices=[96,78,85,100]

d2={item:price for item,price in zip(items,prices)} #{'Fruits': 96, 'Books': 78, 'Others': 85}
print(d2)

d3={item.upper():price for item,price in zip(items,prices)} #{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}
print(d3)

(2)字典元素的获取

# 字典元素的获取
#方法一:
scores={'张三':100,'李四':98,'王五':45}
print(scores['张三'])           #100
#print(scores['李六'])          #KeyError: '李六'

#方法二:
print(scores.get('张三'))       #100
print(scores.get('李六'))       #None
print(scores.get('李六',99))    #99

(3)增删改查

# Key键的判断
scores={'张三':100,'李四':98,'王五':45}
print('张三' in scores)            #True
print('张三' not in scores)        #False

# 删除指定的key-value对
del scores['张三']
print(scores)                     #{'李四': 98, '王五': 45}
# 清空字典元素
scores.clear()
print(scores)                     #{}
# 新增元素
scores['陈六']=98
print(scores)                     #{'陈六': 98}
# 修改元素
scores['陈六']=100
print(scores)                     #{'陈六': 100}

(4)字典的视图操作

# 获取所有的键key
keys=scores.keys()
print(keys)            #dict_keys(['张三', '李四', '王五'])
print(type(keys))      #<class 'dict_keys'>
print(list(keys))      #将所有的key组成的视图转换为列表  ['张三', '李四', '王五']
# 获取所有的值value
values=scores.values()
print(values)            #dict_values([100, 98, 45])
print(type(values))      #<class 'dict_values'>
print(list(values))      #将所有的vlaue组成的视图转换为列表 [100, 98, 45]
# 获取所有的key-value对
items=scores.items()
print(items)            #dict_items([('张三', 100), ('李四', 98), ('王五', 45)])
print(type(items))      #<class 'dict_items'>
print(list(items))      #将所有的key-value组成的视图转换为列表 [('张三', 100), ('李四', 98), ('王五', 45)]

(5)字典的遍历

# 字典的遍历
scores={'张三':100,'李四':98,'王五':45}
for item in scores :
    print(item,scores[item],scores.get(item))   #value key key

(6)字典的特点

①字典的key不允许重复,一旦出现会造成覆盖现象,value可以重复

②字典中的所有元素都是无序的

③字典中的key是不可变对象

④字典可以根据需要动态伸缩

⑤字典是以空间换时间,会造成较多的空间

3.2 元组

1、Python内置的不可变序列的数据结构之一

可变序列:列表,字典,可以进行增、删、改、查操作,且前后地址不变。

不可变序列:字符串,元组,没有增、删、改、查操作。

2、元组的创建

# 元组的创建方式
#方法一:
t=('Python','world',98)
print(t)
print(type(t))

t2='Python','world',98 #方法一省略了小括号
print(t2)
print(type(t2))

#若元组中只包含一个元素,则必须包含逗号和括号
t3=('Python',)
print(t3)
print(type(t3))

#方法二:内置函数tuple()
t1=tuple(('Python','world',98))
print(t1)
print(type(t1))

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

3、元组的遍历

# 元组的遍历
t=('Python','world',98)
for item in t :
    print(item)

 

 

DAY4:

4.1 集合

1、集合的创建

# 集合的创建方式
#方法一:
s={2,3,4,5,6,7,7} #集合中的元素不允许重复
print(s)          #{2, 3, 4, 5, 6, 7}
#方法二:set()
s1=set(range(6))
print(s1,type(s1)) #{0, 1, 2, 3, 4, 5} <class 'set'>

s2=set(['Python','hello',90])
print(s2,type(s2)) #{'hello', 'Python', 90} <class 'set'>

s3=set(('Python','hello',90))
print(s3,type(s3)) #{'hello', 'Python', 90} <class 'set'>

s4=set('Python')
print(s4,type(s4)) #{'h', 'y', 't', 'n', 'P', 'o'} <class 'set'>

s5=set({'Python','hello',90})
print(s5,type(s5)) #{'hello', 'Python', 90} <class 'set'>


#空集合
s6=set()   #直接用s={} 类型为花括号
print(s6,type(s6)) #set() <class 'set'>
 
# 集合生成式
s7={ i*i for i in range(6)}
print(s7)   #{0, 1, 4, 9, 16, 25}
 

2、集合的相关操作

(1)集合元素的判断

In或者not in

(2)集合元素的新增

调用add()方法,一次只添加一个元素

调用update()方法至少添加一个元素

(3)集合元素的删除

调用remove(),一次删除一个指定元素,若不存在抛出KeyError

调用discard(),一次删除一个指定元素,若不存在不抛出异常

调用pop(),一个只删除一个任意元素,不能指定参数

调用clear(),清空集合

3、集合间的关系

# 集合之间的关系
# 是否相等
s1={10,20,30,40}
s2={10,20,30,40,50}
s3={10,20,90}
s4={50,60,70}
print(s1==s2) #False
print(s1!=s2) #True

#一个集合是否是另一个集合的子集
print(s1.issubset(s2)) #True

#一个集合是否是另外一个集合的超集
print(s2.issuperset(s1)) #True

#两个集合是否有交集
print(s1.isdisjoint(s2)) #False  有交集为False
print(s1.isdisjoint(s3)) #False
print(s1.isdisjoint(s4)) #True   没有交集为True

4、集合的数据操作

# 集合的数据操作
#两个集合的交集
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2))   #{40, 20, 30}
print(s1 & s2)               #{40, 20, 30}

#两个集合的并集
print(s1.union(s2))          #{40, 10, 50, 20, 60, 30}
print(s1 | s2)               #{40, 10, 50, 20, 60, 30}

#两个集合的差集
print(s1.difference(s2))     #{10}
print(s1 - s2)               #{10}

#两个集合的对称差集
print(s1.symmetric_difference(s2))       #{50, 10, 60}
print(s1 ^ s2)                           #{50, 10, 60}

4.2 字符串

1、字符串的查询操作

(1)index():查找子串第一次出现的位置,不存在抛出异常ValueError

(2)rindex():查找子串最后一次出现的位置,不存在抛出异常ValueError

(3)find():查找子串第一次出现的位置,不存在返回-1

(4)rfind():查找子串最后一次出现的位置,不存在返回-1

2、字符串的大小写转换操作

(1)upper():把字符串中所有字符都转成大写字母

(2)lower():把字符串中所有字符都转成小写字母

(3)swapcase():把字符串中所有大写字母转成小写字母,把所有小写字母转换为大写字母

(4)capitalize():把第一个字符转换为大写,把其余字符转换为小写

(5)title():把每个单词第一个字符转换为大写,把每个单词的剩余字符转换为小写

3、字符串对齐操作

# 字符串内容对齐操作
s='hello,Python'
#居中对齐,第一个参数指定宽度,第二个参数指定填充字符,第二个字符是可选的,默认是空格,若设置宽度小于实际宽度则返回原字符串
print(s.center(20,'*'))  #****hello,Python****
#左对齐,第一个参数指定宽度,第二个参数指定填充字符,第二个字符是可选的,默认是空格,若设置宽度小于实际宽度则返回原字符串
print(s.ljust(20,'*'))   #hello,Python********
print(s.ljust(10,'*'))   #hello,Python
#右对齐,第一个参数指定宽度,第二个参数指定填充字符,第二个字符是可选的,默认是空格,若设置宽度小于实际宽度则返回原字符串
print(s.rjust(20,'*'))   #********hello,Python
print(s.rjust(20))       #        hello,Python
#右对齐,左边用0填充,只有一个参数指定宽度,若设置宽度小于实际宽度则返回原字符串
print(s.zfill(20))       #00000000hello,Python

4、字符串的劈分

# 字符串的劈分
# split  从左边开始劈分,默认劈分字符是空格字符串,返回值是一个列表,通过sep指定劈分字符,maxsplit指定最大劈分次数
s='hello world python'
print(s.split())                      #['hello', 'world', 'python']
s1='hello|world|python' 
print(s1.split(sep='|'))              #['hello', 'world', 'python']
print(s1.split(sep='|',maxsplit=1))   #['hello', 'world|python']

# rsplit 从右边开始劈分,默认劈分字符是空格字符串,返回值是一个列表,通过sep指定劈分字符,maxsplit指定最大劈分次数
s='hello world python'
print(s.rsplit())                     #['hello', 'world', 'python']
s1='hello|world|python'
print(s1.rsplit(sep='|'))             #['hello', 'world', 'python']
print(s1.rsplit(sep='|',maxsplit=1))  #['hello|world', 'python']

5、判断字符串操作
#isidentifier():判断指定的字符串是不是合法的标识符
#isspace():判断指定的字符串是否全部由空白字符组成(回车、换行、水平制表符)
#isalpha():判断指定的字符串是否全部由字母组成
#isdecimal():判断指定的字符串是否全部由十进制的数字组成
#isnumeric():判断指定的字符串是否全部由数字组成
#isalnum():判断指定字符串是否全部由字母和数字组成

6、字符串的替换和合并

# 字符串的替换和合并
# replace:替换,第一个参数指定被替换的子串,第二个参数指定替换子串的字符串,,第三个参数指定最大替换次数
s='hello,Python'
print(s.replace('Python','Java'))           #hello,Java
s1='hello,Python,Python,Python'
print(s1.replace('Python','Java',2))        #hello,Java,Java,Python

# join:合并,将列表或元组只的字符串合并成一个字符串
lst=['hello','Java','Python']
print('|'.join(lst))                        #hello|Java|Python
print(''.join(lst))                         #helloJavaPython

t=('hello','Java','Python')
print('|'.join(t))                          #hello|Java|Python
print(''.join(t))                           #helloJavaPython

print('*'.join('Python'))                   #P*y*t*h*o*n

7、字符串的比较操作

运算符:>,>=,<,<=,==,!=

8、字符串的切片操作

# 字符串的切片操作
#切片[start:end:step]
s='hello,Python'
s1=s[:5]
s2=s[6:]
s3='!'
newstr=s1+s3+s2
print(s1)             #hello
print(s2)             #Python
print(newstr)         #hello!Python

9、格式化字符串

#(1) %占位符 类似C语言
name='张三'
age=20
print('我叫%s,今年%d岁' % (name,age))      #我叫张三,今年20岁
print('%10d' % age)                      #        20  占10位

#(2) {}
print('我叫{0},今年{1}岁'.format(name,age)) #我叫张三,今年20岁
print('{0:.3}'.format(3.1415926))        #3.14
print('{0:.3f}'.format(3.1415926))       #3.142
print('{0:10.3f}'.format(3.1415926))       #一共是10位,三位小数

#(3)f-string
print(f'我叫{name},今年{age}岁')           #我叫张三,今年20岁

10、字符串的编码与解码

# 字符串的编码与解码
s='天涯共此时'
#编码
print(s.encode(encoding='GBK')) #在GBK这种编码格式中,一个中文占两个字节    b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'
print(s.encode(encoding='UTF-8')) #在UTF-8这种编码格式中,一个中文占三个字节   b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6'

#解码
byte=s.encode(encoding='GBK')
print(byte.decode(encoding='GBK'))   #天涯共此时

 

 

DAY5:

5.1 函数

1.函数的创建与调用

# 函数的定义与调用
def calc(a,b) :
    c=a+b
    return c

result=calc(10,20)
print(result)
 
# 函数返回值为多个时,返回数据类型为元组

2.个数可变的位置参数与个数可变的关键字形参

# 个数可变的位置形参    输出形式为元组形式  只能是一个
def fun(*args):
    print(args)

fun(10)            #(10,)
fun(10,30)         #(10, 30)
fun(30,405,50)     #(30, 405, 50)

# 个数可变的关键字形参   输出形式为字典形式 只能是一个
def fun1(**args):
    print(args)

fun1(a=10)            #{'a': 10}
fun1(a=10,b=30)       #{'a': 10, 'b': 30}

# 在一个函数的定义过程中,既有个数可变的关键字形参,又有个数可变的位置形参
# 要求:个数可变的位置形参需要放在个数可变的关键字形参之前
def fun2(*arg1,**arg2):
    pass
 
# 需求:c,d只能采用关键字实参传递
def fun3(a,b,*,c,d):
    pass

3、实参用法

# 调用参数用法
def fun(a,b,c):
    print('a=',a,'b=',b,'c=',c)

# 在函数调用时的参数传递,称为位置传参
fun(10,20,30)                   #a= 10 b= 20 c= 30
# 在函数调用时,将列表中的每个元素都转换为位置实参传入
lst=[11,22,33]
fun(*lst)                       #a= 11 b= 22 c= 33
# 函数的调用,所以是关键字实参
fun(a=100,b=200,c=300)          #a= 100 b= 200 c= 300
# 在函数调用时,将字典中的键值对都转换成关键字实参传入
dic={'a':111,'b':222,'c':333}
fun(**dic)                      #a= 111 b= 222 c= 333

4、函数内部定义的变量为局部变量,如果在局部变量前使用global声明,这个变量实际上就变成了全局变量

 

posted @ 2023-04-09 21:30  拼命搬砖的黎小梨  阅读(83)  评论(0编辑  收藏  举报