Python是一门非常方便省时间的语言
由我自己学过C语言的基础上来学习的时候,Python省略了很多很多的条条框框,同时又是一门面向对象的语言,所以在学习的过程中与C#非常相似。
因此,本篇文章适用于什么基础都没有的同学,但即使是这样,我还是希望各位学习一下C或Java,先难后易,Python相比于这几门确实是简单的,所以先难后易,先苦后甜会更甜。
在print的引号前加一个r/R后,不管引号后面的字符串里面是否有转义字符都会将其看做一个字符,也就是完整的输出,\r就给你输出\r,没有回车的效果了
Python的变量名与其他语言差不多,都是for ,if 等等这些关键词是不能作为变量名。
总结:单双引号没有区别,但是Python中与C有区别的是使用多少个引号一次性使用三次引号的能够在引号间进行换行书写内容。
任何类型都能将其转换为str字符串类型
str(其他类型),然后就能直接把整个str(类型)输出
注意事项:在Python中使用print输出的只能为str类型,所以当你想直接输出变量名的时候要确保该变量名是str 类型否则
age = 20 print(str+age)这样是不成立的
只有将age转化为str类型才能将其输出,print(str(age))这样就能进行输出了。
但是当你单独直接输出print(age)是可以的,也就是说两个不同类型的不能用+连起来。
如果都是int类型用+号连接起来就变成了将两个数进行加法运算
转为int类型变量
当想要把str转化为int类型之前要检查一下str里面的内容是否是全数字,否则将不能转换。
注意:由于bool 类型是由01构成的,所以bool类型是能够直接转化为int类型的。
转换为float类型变量
同int类型一样,bool和字符串全为数字的时候能转为float。
int类型转为float的话就是在整数后面加上.0小数点,同理bool类型是由01构成,所以也是在01后面加上小数点。
总结:在Python中的类型转换与C语言是有着异曲同工之妙处,因为在C中将类型转换是在变量名前面加括号和类型名,如:(double)age,这样就能将age强制转换为double类型,而Python中则是直接使用类型名加括号,直接把变量放在括号里面就完成了转换。这样的转换方式在后面我相信会看到更多,比如想要看该变量是什么类型的就用type(变量名),Python中常见的方式都是用这种很直观的方式进行代码编写。
可能这也是Python创始人为什么说:“人生苦短,我要用Python”的原因了。
使用 #
#代表在他后面的并且在同一行的内容都是注释,计算机在运行的时候会忽略里面的内容进行执行代码。
使用三个单引号
该方法解决了#只能进行单行注释的缺点,在同时上面讲到三个单引号在print进行输出字符串的时候使用三个单引号或者三个双引号能在里面进行换行输出。
注释中也能使用三个单引号,这时候直接使用三个单引号,里面的内容也能进行多行注释,并且计算机不会执行这些语句。
注意事项
多行注释不能使用三个双引号,这是不符合语法规则的,具体我这个菜逼还不知道,但是想想也有道理,人家Python都创造出来为了方便我们不用再按Shift进行双引号才能删输出字符串了,当然为了更方便点直接裸用三个单引号进行多行注释也不为奇怪。
#的另一种用法
在整个代码的第一行写#coding : utf-8或者其他编码方式
该意思就是当你用记事本打开你写的Python代码的时候是用什么编码方式打开的,在 第一行写上
#coding : 编码方式,
从一开始就决定了你写的代码在用记事本打开的时候是用什么编码房室结进行打开查看的。
(目前还不知道这个功能有什么用ing……)
print(1+1) #加法运算
print(2-1) #减法运算
print(11/2) #除法运算
print(11//2) #整除运算
print(2**5) #幂运算
在Python中新知识点如下:
填写两个除号就是进行整除运算,把小数点去掉(不进行四舍五入)
但是在一正一负中,所得的结果要向下取整
解释:当在进行整除运算的时候如果出现一正一负的情况,所得的结果肯定是负数,向下取整的意思就是有小数点的话就要往更小的值去取。
比如正常除法得到的结果为-2.2:那么结果整除结果就是-3(比-2.2更小,即向下取整)
特别提醒:
!当我们用float类型进行整除的时候,出来的结果是要带小数点的,我们只是把小数点那些数给扔掉,但是我们没有把该类型的精度给扔掉,这点是很重要的。
前面的数是底数,两个乘号后面是指数
2**5 :2的5次方 == 32
print(9%-4)
print(-9%4)
结果:
-3
3
这个是一个细节,因为我们都知道运算方式,但是我们在写的时候通常会忽略这个点,所以常常以为结果都是3,但其实不然。
#赋值运算符
在Python中与其他语言的赋值没什么区别,
但是多了一个就是Python能进行按系列解包赋值,说人话就是按顺序一个一个对应赋值
#按照顺序进行赋值
a,b,c = 1,2,3
print(a,b,c)
结果就是abc分别对应123三个数
Python中与其他语言不太一样的是有一个能对ID地址进行比较的运算
a = 10
b = 10
print(a==b)
print(a is b)
结果截屏:
解释:
is是通过比较两个变量的ID地址
然后如果是变量类型的数值,如果值相同但赋值给不同变量名,
在你第二个变量名赋值之前,会在计算机中寻找有没有开辟过该空间的值,
有的话就把该ID地址也给第二个变量
所以在比较ID地址的时候,如果值相同的话,ID地址也会相同
注意:当你给不同的数组或者集合赋相同的值的时候,用is将两个变量进行比较的结果是false,也就是这两个变量是不一样的,因为数组你每次开辟一个空间都会另外开一块地方给你,而不是再次在同一块地方给你进行使用,这样就是解释了每次开辟数组空间都要谨慎考虑你需要的空间是多大,而不能盲目的开辟空间。
Python中的布尔运算与C不一样,C中是使用&&,|| 与或运算
但是在Python中与运算变成了and,或运算变成了or其实也就是更容易让人看懂,这也就是Python的魅力所在。
ch = 'hello word'
print('hello' in ch)
#结果为True,也就是该字符串hello包含在ch字符串变量里面
算术运算符 > 位运算符 > 比较运算符
在Python中万物皆可对象,因此都有对应的True或者False值,所以Python中内置了一个函数bool(对象),用来判断是否为真值或者假值。
在Python中的循环结构和函数结构都没有大括号的。
例如在if结构中:
#提问成绩
grade = int(input('请输入你的成绩:'))
if(90<=grade<=100):
print('你的等级为A')
elif(grade >= 80 and grade <= 89):
print('你的等级为B')
elif(grade >= 70 and grade <= 79):
print('你的等级为C')
elif(grade >= 60 and grade <= 69):
print('你的等级为D')
elif(grade >= 0 and grade <= 59):
print('你在学什么?')
else:
print('你输的是哪门子的成绩?')
细节小知识点
Python中的条件表达式有点类似于C语言中的三目运算符
解释:如果IF条件满足,那就执行语句1,否则执行语句2
条件判断可以不用加括号也符合语法规则
#条件表达式
num1 = int(input('请输入第一个数字:'))
num2 = int(input('请输入第二个数字:'))
print(str(num1)+'>'+str(num2) if (num1 > num2) else str(num1)+'<'+str(num2))
该语句是纯纯的一个万能不报错占位符,也就是说该pass部分我还没想好怎么写的时候我可以先用pass占个位置,等我运行的时候也不会报错,让我想好了怎么写了再把pass去掉,填上自己要写的代码。
这通常用的一个结构语句中,例如if else ,if之后的执行的代码我还没想好我就可以填一个pass进去充当占位符,如果不填就会报错。
n1 = 5
n2 = 6
if(n1 > n2):
pass
else:
pass
这样就是pass的作用,目的很简单,给你占个位置,啥也不执行,但就是不会给你报错,这就极大地利于我们在写一个项目的时候,搭建框架的时候非常有用。
#range内置函数
#只给一个参数,即一个结束范围,不包含该参数,默认从0的闭区间开始,10为开区间
r1 = range(10)
print(r1)
print(list(r1)) #list是一个列表,将r1中的数字都列出来
#给两个参数,即一个区间范围
r1 = range(1,10)
print(r1)
print(list(r1))
#给三个参数,前面两个为区间范围,第三个参数为步长,前面两个的步长都为1,也就是两个数字之间的间隔是1
r1 = range(1,10,2)
print(r1)
print(list(r1))
该循环有点像C#中的foreach
在C#中foreach : 循环参数(var item in 对应的集合)
然而在Python中的for in里面他是这样操作的
for item in 集合
该集合可以是一串字符串,那么item提取出来的便是一个个字符
例如:
for item in 'Python'
print(item)
#该操作就是从Python中一个一个字符提取出来然后赋值给item将其输出。
可以结合前面学习到的range函数,将其中所创建的数字都按照顺序一个个输出出来
for i in range(10)
print(i)
#该代码执行的操作就是将range作为一个集合,然后把集合中的元素将其输出打印
for _ in range(5):
print('皇上驾到!')
#当我们不需要有一个变量进行输出的时候我们就用下划线代替变量名,然后用range作为循环体执行次数,因为在range中他是左闭右开区间,所以5是不包含的,但是又因为是从0开始,所以他还是会执行5次,这也是为什么在C语言中,经常有大佬提倡在for循环的执行次数中秉持着从0开始的执念。
当我们使用for in 和while 的时候,在循环结束不是用break退出的时候就能进入到else的语句执行代码。
解释:
for in:
…
…
else
假入你的for in循环中,退出循环的是集合中的元素都扫描过了,也就是正常条件退出的时候就不会执行else语句里面的代码。
但是如果在循环中退出是因为进入了break语句才强行退出的话,那么在退出循环后就会进入else语句里面执行代码体。
打个比喻:当你正常在考试中按照时间交卷退出考场的话就没人会理你,也没人会找你,但是当你还没到考试结束时间你就退出了,那么肯定会有监考老师来问你,那么这个else干的就是监考老师这个事情。
同理在使用while循环体与else搭配也一样的效果
代码如下:
#else与循环搭配使用
#与for in搭配
for item in range(3):
if(input('请输入密码:') == '8888'):
print('密码正确!')
break
else:
print('密码错误')
else:
print('三次密码均错误!五分钟后再次操作')
#与while搭配使用
time = 3
while time > 0:
pws = input('请输入密码')
if(pws == '8888'):
print('密码正确')
break
else:
print('密码错误')
time-=1
else:
print('三次密码均错误!五分钟后再次操作')
创建列表的两种方式
列表切片
定义了一个列表变量名后就可以使用列表切片
lst = [10,20,30…]
#列表的步长
lst = [10,20,30,40,50,60,70,80]
print(len(lst))
print(lst.index(50))
#切片,步长均为正的情况下
print(lst[1:5:1])
print(lst[:5:1])#默认start下标0
print(lst[1::1])#默认end下标7-即结束的下标
print(lst[::2])#开始和结束下标均默认
print(lst[2:5:])#默认步长为1
#切片,步长为负的情况下
print('--------步长为负-----------')
print(lst[::-1])
#当步长为负数的时候,你就要把start和end下标两个对换一下,因为步长负数需要从start开始减
#因此步长为负数的时候就默认start从末尾开始,end下标从0开始
lst = [1,5,6,9,8,4]
lst.remove(5)
#lst.pop()#如果不给pop的要删除的下标的话默认会自动删除掉最后一个元素
#lst.pop(3)#表示要删除的元素为下标为3的元素
#使用切片进行切块删除
#切片是按照一块一块的切,把你需要留下的切下来
#比如我需要把下标为0~3的元素留下,把剩下的删除掉
print(lst[0:4])
lst2 = [20,30,40,50,60]
lst2[1:3] = []#将空列表赋值给切出来的这一块元素,就变成了删除这几个元素的操作了
print(lst2)
切片这个词语不仅在代码中出现,在PS中我也是有用,其功能是一样的,都是把一个对象切块。
比如在Python中切片就是在给出的范围内进行切片,将该范围的元素切出来,所以切片操作就能够当作是添加元素也能用来删除元素。
添加元素则需要两个列表,就是在另一个列表上切出一块来,然后补到你想要加入元素的列表中。
总而言之:切片就是将列表一块地方切出来,怎么操作还是取决于你的怎么写。
也是使用切片,也可以不用,直接用下标找到你要修改的元素直接修改就好了。
lst = [1,6,59,614,6664,94,8]
#使用切片切出来,然后对着块地方进行修改
lst[2:5] = [55,555,5555]
print(lst)
Python中非常方便,这些排序方法根本不用我们自己写,只需要记住有这个方法就行,英语稍微好点的一看就知道是干嘛用的了。
#列表排序
#lst.sort()#直接使用列表中带的方法,从小到大排序,排正序
#lst.sort(reverse=True)#排序将变成逆序排序,同样如果不写False就会默认为True
#new_lst = sorted(lst) #使用内置函数进行排序,该排序是正排序,从小到大
new_lst = sorted(lst,reverse=True) #逆序排序,从大到小
print(new_lst)
结合着for循环和range内置函数搭配使用就是列表生成式
就是在中括号中使用range函数生成一个元素范围,然后使用for循环用一个i变量把range中的元素提取出来,然后再把那个变量放在中括号第一个位置就是相当于把该变量放在了列表中。
看下面实战代码:
l = [i for i in range(1,6)]
print(l)
l2 = [i*2 for i in range(1,6)]
print(l2)
该字典其实就相当于hashtable,在C#中有用到过,其实说白了也是通过键值对查找相应的值。
在Python中我发现键的定义必须是字符串(第二种创建方式有小小出入),然后键对应的值就可以是任意类型的。
需要注意的是,键值对是用冒号隔开的,左键右值
解释:首先必须接受的事实就是键的类型必须是字符串,在第一种直接创建方式中就很直接明了,字符串键对应一个值。
其次,在第二种方式中,键类型不能直接是字符串形式,而是通过变量名形式加一个等号表示该变量名对应该值,为什么说第二种方式键也是字符串呢,因为我在将整个字典输出的时候发现是以字符串形式输出的,并且在寻找值的时候,用的也是键的字符串形式。
代码如下:
#创建字典的第一种方式
#键的命名必须是字符串形式
dit = {'张飞': '646', '关羽': 20, '刘备':60,'李白':99}
print(dit)
#第一种通过中括号输入键找到值,就像列表通过下标找数值一样
print(dit['张飞'])
#当你输入的键是不存在的,那么就可以输入第二个参数作为该不存在的键的值
print(dit.get('皇帝', '万众瞩目'))
#创建字典的第二种方式
#键的命名必须是变量名形式,但是输出的时候会自动变为字符形输出,因此在用键查找的时候依旧是用字符串形式进行查找
dit2 = dict(age=20,name='汤姆',s = 20)
print(dit2)
print(dit2['name'])
for item in dit:
print(item,dit.get(item))
修改,增肌,删除操作代码如下:
dit = {'张飞': '646', '关羽': 20, '刘备':60,'李白':99}
print(dit)
#通过找到键名修改键值
dit['张飞'] = 65
print(dit)
#如果没有找到该键名就会自动创建该键名,然后把该键值赋值进去
dit['皇帝'] = 520
print(dit)
#删除
del dit['张飞'] #删除单个键值对,通过填入键名,将其键值对都删除掉
#dit.clear() #该方法是清除字典里面所有键值对
print(dit)
获取键组,dit.keys()
获取值组,dit.value()
获取键值组,也成元组,dit.items()
代码如下:
dit = {'张飞': '646', '关羽': 20, '刘备':60,'李白':99}
print(dit)
#获取键组
key = dit.keys()
print(key,type(key))
#获取值组
value = dit.values()
print(value,type(value))
#获取键值组,也成元组
item = dit.items()
print(item,type(item))
#键
item = ['张飞','皇帝','李白']
#值
value = [5,999,999,123456]
#使用列表,将两个列表压缩为一个字典。一个作为键,另一个作为值
dit = {item : value for item,value in zip(item,value)}
print(dit)
假如你的键item为字母,但是你想全部变为大写形式,只需要修改一个地方即可,其他地方不用修改。(因为我的键全是中文,所以我没用.upper)
修改地方:dit = { item : value for item,value in zip(item,value)}
将 item 改成 item.upper() ,那么就变成了
dit = { item.upper() : value for item,value in zip(item,value)}
#创建元组方式
#第一种方式
#元素使用小括号
t = (5,4,9,3)
print(t, type(t))
#假如只有一个元素,需要加一个逗号加以区分你创建的是一个元组,不然会自动认为你该一个元素为一个类型变量值
t1 = (5,)
print(t1,type(t1))
#也可以省略小括号的方式创建元组
t2 = 5,
print(t2,type(t2))
#第二种方式
#使用内置函数tuple,但是记得要在括号内创建元组时候也要加小括号,否则会报错
t3= tuple((5,8,96,'皇帝'))
print(t3,type(t3))
#传列表进去创建一个元组元素为列表的元组
t4 = tuple([1,2,3,4])
print(t4)
#元组是不可变的
t = (6531,[13,65,1],'皇帝',1.2)
print(t)
#我们不能直接修改元组中的元素
print(t[2])#通过下标元素访问元组中的元素,但是不能通过获取元素方式修改元素值
#元组不可变,但是我的元组元素是列表,我的列表可变
t[1].append('新来的')
print(t)
#集合的创建
t1 = {1,5,'jackson',4.0}
print(t1)
#输出后发现顺序乱的,说明了集合是无序的,每次输出都有不一样的结果
#使用set内置函数传参只能传一种数据结构,或者传一组不含数据结构的元组
t2 = set([1,5,8,'我是列表'])
print(t2)
t3 = set({5,8,9,6,'我是字典'})
print(t3)
#不允许多个参数,只允许传数据结构进去并且只能有一个数据结构
#将字符串变成一个一个字符,然后存到集合中,因为字符串本身就是一个字符的集合
t4 = set('python')
print(t4)
#使用set用元组创建集合
t5 = set((4,5,6,'我是元组'))
print(t5)
#空集合
#t = {} #这样不是空集合,因为空字典已经这样定义了,所以我们要用内置函数set来定义空集合
t6 = set()#什么都不写就是空集合
print(t6,type(t6))
t7 = set({'张飞': '646', '关羽': 20})
print(t7)
#把键作为集合元素输出,值丢掉
元素的增加:
#集合的创建
t = {1,5,'jackson',4.0}
print(t)
#集合的添加
#使用集合自带方法add,添加一个元素,不能添加多个或者数据结构,因为数据结构里面可能包含不止一个
t.add(999)
print(t)
#使用update方法,可以添加一个数据结构,但是不能把多个元素拆开传进去,因为
t.update({1,5,8,9})
print(t)
元素的删除:
#集合的创建
t = {1,5,'jackson',4.0}
print(t)
#集合的删除
#删除特定的元素,假如没有该元素则会报错
t.remove(1)
print(t)
#删除特定元素,假如没有该元素不会报错
t.discard('元素不存在')
print(t)
#随机弹出一个元素,也就是删除
print(t.pop())
print('弹出随机一个元素后的集合是:',end='')
print(t)
#删除所有元素
t.clear()
print(t)
示例代码如下:
s1 = {1,2,3,4,5,9,55,7,6}
s2 = {1,3,4,2}
s3 = {5,6,9,7,1}
s4 = {5,6,9}
#判断是否为子集,只要元素相同就行,小的是大的子集,否则不能
print(s1.issubset(s2)) #s1是否为s2的子集
print(s2.issubset(s1)) #s2是否为s1的子集
#sub这个词在C#中出现过,是截取字符串的函数名中出现,所以我的理解是is sub意思是:s1是截取在s2中,是就返回true否就false
#判断是否为超集,超集就是和判断是否为子集相反,大的就是小的超集,小的是大的子集
print(s1.issuperset(s2))
print(s2.issuperset(s1))
#判断是否 没有 交集,判断的是没有交集,如果没有就返回true,有就返回false
print(s3.isdisjoint(s4))
print(s2.isdisjoint(s4))
补充:
集合生成式
与列表生成式一模一样,只是把中括号[ ]改成花括号而已。
s = {i for i in range(5)}
print(s,type(s))
发生驻留机制的几种情况:
符号标识符的字符串
当你赋予两个变量不符合标识符的字符串,即使两个变量字符串相同,也不会产生驻留机制,也就是说浪费空间,你用两个不同的空间存了两个相同的字符串。
举个栗子:
当你比较二者地址的时候明显是返回一个False,表示不一样的空间。
(因为我这里的减号为不符合标识符的字符串。)
字符串长度为0或者1的时候
该条件适用于当你输入了不符合标识符的字符的时候用,因为有些时候就是想存一个标识符作为字符串,比如存一个减号加号之类的,这时候字符串长度为1,即使是不符合标识符的也能发生驻留机制,将相同的字符串保留一份,无须再创建多一份。
为了方便解释,设a为字符串
a.upper()
把字符串中的所有字母转换为大写
a.lower()
把字符串中的所有字母转换为小写
a.swapcase()
把字符串中的小写转为大写,大写转为小写。
(就是反转一下)
a.capitalize()
把字符串中的首个字符转为大写,剩余的就转为小写
a.title()
把字符串中的每个单词的首字母都变为大写,然后单词首字母后的都转为小写
需要说明的细节
当我们转换后的字符串是会产生一个新的字符串对象,也就是说不再是原本的那个字符串指向的地址,即不是原字符串了,而是给你开辟了一个新的空间地址存放该转换后的字符串。
上面的转换都会产生这样的效果。
实验代码如下:
s = 'Hello,Python'
#字母的大小写转换
#全部字母转换为大写字母
s2 = s.upper() # 转换后会产生新的字符串空间地址存放
print(s,id(s))
print(s2,id(s2))
#全部字母转换为小写字母
s2 = s.lower();
print(s,id(s)) # 转换后会产生新的字符串空间地址存放
print(s2, id(s2))
#大小写字母相互转换,即在字符串中小写变大写,大写变小写
s2 = s.swapcase()
print(s2,id(s2))
print(s,id(s))
#字符串中首字母转为大写后,后面的不管怎样其他都为小写
s2 = s.capitalize()
print(s2,id(s2))
print(s, id(s))
#字符串中每个单词的首字母转换为大写,单词首字母后均为小写(区别于capitalize)
s2 = s.title()
print(s2,id(s2))
print(s,id(s))
为了方便我们设字符串为a
实验代码如下,里面我写了关于zfill对于加减号的特殊情况发生的代码,可以试着多次换符号进行实验。(如有发现除了加减符号也能产生该情况的话务必私信我,感谢大佬们)
#输出格式排版
s = 'hello,python'
#居中对齐
#第一个参数必填:表示该字符串按照多少个位置居中对齐
#第二个参数非必填:表示填充的符号,不填写就是默认为空格
#假如第一个参数小于字符串长度则直接返回原字符串
print(s.center(20,'*'))
#左对齐
#第一个参数必填:表示该字符串按照多少个位置左对齐
#第二个参数非必填:表示填充的符号,不填写就是默认为空格
#假如第一个参数小于字符串长度则直接返回原字符串
print(s.ljust(20,'&'))
#右对齐
#第一个参数必填:表示该字符串按照多少个位置右对齐
#第二个参数非必填:表示填充的符号,不填写就是默认为空格
#假如第一个参数小于字符串长度则直接返回原字符串
print(s.rjust(20,'$'))
#右对齐,用0填充
#如果加减号在字符串第一个位置,则0会填充到加减号后面
#只能填一个参数,因为填充符号固定了
s2 = '+jj'
print(s2.zfill(20))
为了方便设a为字符串变量
食用提醒
下面的函数参数有最多有两个。
首先第一个参数为分隔符,即一个字符串中,你按照哪个分隔符进行分割
分割完成后就返回一个列表,把你分割好的做成一个列表形式返回。
分隔符参数名为:sep
分割个数参数名为:maxsplit
所以在写参数的时候可以用sep=‘’的形式来写,也可以不写出参数名,直接填写分隔符和分割个数,二者一样。(代码中我都写出了几种情况)
a.split(参数1,参数2可写可不写)
表示从字符串开始分割,遇到参数一填写的字符串分割符就分割开,直至字符串结束,把分割好的几部分以列表的形式返回。
a.rsplit(参数1,参数2可写可不写)
表示从字符串尾部开始分割,遇到参数一填写的字符串分割符就分割开,直至字符串的头部结束,把分割好的几部分以列表形式返回。
两个方法的区别
显而易见的区别就是分割的顺序不一样,split一个是从左到右分,rsplit另一个是从右到左分
最本质的区别就是当你规定了分割个数之后,区别就非常大,可以运行下我下面的代码。两个字符串明显分割的部分不一样了。
试验代码如下:
# 字符串的劈分
#使用split,分割字符串内容,返回的是列表。
#参数是分割字符串的标识符,就是按照你传参的该字符进行分割,字符串中遇到该字符就分割,然后该字符不列在元素当中,仅当为分割符
s = 'hello|word|python'
print(s.split('|'))
print(s.split('|',1))
print(s.split(sep='|'))
print(s.split(sep='|',maxsplit=1))#写出sep参数等于多少(即分隔符是什么),与不写是一样的。同理maxsplit写不写也是一样的效果。
#使用rsplit从尾部开始分割
s1 = 'hello|love|me'
print(s1.rsplit('|'))
print(s1.rsplit('|',1))
print(s1.rsplit(sep='|',maxsplit=1))
为了方便就设字符串变量为a
该模块很难简单,基本面向对象语言都有该功能函数,就不进行代码实验了。
为了方便设字符串变量为a
s = 'hello python java python'
#replace表示字符串中所有的指定在主字符串中,把方法参数一字符串,替换成参数二的字符串
print(s.replace('k','java'))
# 假设传入第三个参数,表示你在主字符串中替换的次数
print(s.replace('python', 'java',1))
# join
lst = ['hello','python','java','C#']
print(' '.join(lst))
t = ('666','python','C#')
print('|'.join(t))
'''
集合不能被衔接,具体原因目前还不知道
se = {1,5,'hello',666}
print('&'.join(se))
'''
a = 'apple'
b = 'banana'
print(a>b)
我个人感觉字符串切片没什么好说的,就是把字符串看成列表一样,写法也和当时列表切片一模一样,
就是三个参数,start: end: step。
s = 'hello python'
print(s[-6::1])
print(s[6::1])
print(s[4:])
print(s[:3])
在这个模块解决了我对print输出的所有疑惑和小细节
#格式化输出
name = 'LOVE'
num = 220901
#使用%占位符输出
print('时间:%d 姓名:%s'% (num,name))
#使用{}占位符输出
#占位符中的数字可以不填,但是一般规范点要填
print('时间:{}'.format(num))
print('时间:{0} 姓名:{1}'.format(num,name))
在定义一个函数的时候我们直接写参数个数时,也可以直接给形参赋初值,这就是所谓的默认值,当我们调用函数的时候,有默认值的参数是可以选择不填,因为有默认值了。假设你要传进来也可以,同时会改变该函数的默认值。
#函数参数默认值
def calt(a,b=10):
print(a)
print(b)
return
calt(1,55)
calt(5)
假定一个函数名为Fun(可变参数)
lst = [1,4,5,2]
t = (8,8,9,9,5)
s = {888,999,777,666}
dit = {'人':9,'Jackson':66}
def fun2(*args):
print(args)
return
fun2(lst)#该传参形式是以一个列表形式传进去
fun2(lst,t,dit,s)# 把各个数据结构作为元组元素传进去
fun2(*lst)#该传参形式是把列表分解开来传进去
fun2(*t)
fun2(*s)
fun2(*dit)#字典也可以实现拆开成一个个元素传进去,拆开的是字典的键,键作为元组的元素放进去
fun2(*'helloword')
fun2(1,4,5,8)
# 关键字参数,即键值对,将参数返回的时候为字典类型
def fun3(**args):
print(args)
args.clear()
return args
dit2 = fun3(a=2,b=9)
print(dit2,type(dit2))
#不能直接传一个字典进去 fun3(dit)
#所以要用一个**放进去解开字典所有元素传进去
fun3(**dit)
ss = 'hello,python'
def fun4(*args1,**args2):
print(args1,args2)
return
fun4(1,4,5,2,a=8,c=8)
fun4(ss) #表明在可变参数中,尽管有一个可变序列和一个关键字可变参数,都不填或者填一个都行,什么叫可变参数,即想填多少就填多少,不填也行
斐波那契数列:
1 1 2 3 5 8…
就是从第三个数字开始,前两个数字的和作为该数字的值1+1=2第三个数为2
1+2=3,第四个数为3,以此类推。
#斐波那契
def fib(n):
if(n==1):
return 1
elif(n==2):
return 1
else:
return fib(n-1)+fib(n-2)
print(fib(6))
#使用循环把前6个斐波那契数打印出来
for i in range(1,7):
print(fib(i),end='\t')
下面的try部分接的都是执行代码,试错代码部分,假设代码出错就会执行execpt的捕获错误部分的代码。
当我们明确是哪种错误类型之后就可以对应好下面的错误捕获来使用:
代码如下:
try:
n1 = int(input(':'))
n2 = int(input(':'))
reslut = n1/n2
print(reslut)
except ZeroDivisionError:
print('除数不能为0')
except ValueError:
print('值输入错误')
except BaseException as E:
print(E)
继续补充几个常见的错误捕获,但不进行代码演示了,因为都一样的写法
try:
n1 = int(input(':'))
n2 = int(input(':'))
reslut = n1 / n2
print(reslut)
except BaseException as E:
print(E)
else:
print('try完了就继续执行我这个语句')
try:
n1 = int(input(':'))
n2 = int(input(':'))
reslut = n1 / n2
print(reslut)
except BaseException as E:
print(E)
else:
print('try完了就继续执行我这个语句')
finally:
print('管你错没错误,我就执行')
在Python中万物皆对象
class Student:
locate = '广东'
#初始化属性,创建对象时的参数,可以自己在参数中赋值使之拥有默认值,防止报错
def __init__(self,name,age = 2):
self.name = name
self.agess = age
def sayhello(self):
print("你好我是:%s, 今年%d岁"% (self.name,self.agess))
@classmethod
def cm(cls):
print('我是类方法,可以使用类名使用我,也可以用对象使用我')
@staticmethod
def stfun():
print('我是静态方法,可以使用类名使用我,也可以用对象使用我')
stu = Student('孙悟空',2000)
stu.sayhello()
stu.cm()
Student.cm()
stu.stfun()
Student.stfun()
Student.sayhello(stu)#这样调用对象方法也可以
首先创建一个Student类,然后使用def _ _ init _ _(self,name,age = 2) : 初始化属性。
动态的解释
我们创建一个类之后就会创建一个对象,该对象拥有类的所有功能和属性,当我们发现创建的类已经不满足对象的需求时,即属性和功能不够对象用了,这时候就需要动态的为对象添加他所需的属性和功能。
动态绑定属性
假设对象名为 stu1
现在需要加多一个性别属性给stu1该对象,我们直接添加就好
如:stu1 . gerder = ‘男’
gerder是前面不存在的属性,我们直接在这创建出来给他赋值就是一种动态绑定属性。
也就是说gender该属性名是随意起的,现在要做的工作就是添加一个在类中不存在的属性。
动态绑定方法
假设对象名为stu2
现在需要加多一个方法给stu2该对象,我们同样可以直接添加,
如:stu2 . show = show
注意:show是我们在程序中定义的函数方法体,show可以和你要在对象中添加的方法名一样,只要你把show函数定义了就行。
然后就可以使用stu2 . show()了,功能和你在程序中定义的show方法功能一样。
#动态绑定属性和方法
class Student:
def __init__(self,name,age):
self.name = name
self.age = age
def eat(self):
print(self.name+'在吃饭')
stu1 = Student('张三',20)
stu2 = Student('李四',25)
stu1.eat()
#动态添加一个性别属性
stu1.gender = '男'
print(stu1.gender,stu1.name)
#stu2没有添加该属性就不能够使用,因为这是专属于张三的属性,不是class类中共同的属性
#动态添加一个方法
def sayhello():
print('你好,我是学生')
stu2.sayhello = sayhello
stu2.sayhello()
语言不如代码来的实际
继承示例代码如下:
#实现继承类
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
def show(self):
print('我是学生,名字是:{0}、 年龄:{1}'.format(self.name,self.age))
#一般类中都会重写该方法,因为方便查看该类是什么
def __str__(self):
return '我是人类父类'
class Student(Person):
def __init__(self,name,age,score):
super().__init__(name,age)
self.score = score
def show(self):
super(Student, self).show()
print('学生需要学号:',self.score)
def __str__(self):
return '我是学生类,继承于人类'
stu = Student('jackson',20,'1001')
stu.show()
print(stu)
print(type(stu))
代码如下:
#实现多态
class Animal(object):
def eat(self):
print('动物吃东西')
class Student(Animal):
def eat(self):
print('学生正在吃饭')
class Dog(Animal):
def eat(self):
print('狗正在吃骨头')
class Cat(Animal):
def eat(self):
print('猫在吃鱼')
class Bird(Animal):
def eat(self):
print('鸟在吃虫')
def funeat(Animal):
Animal.eat()
funeat(Dog())
funeat(Cat())
funeat(Student())
funeat(Bird())
特别说明一下该函数的用处,该函数能够显示出一个对象中有什么属性,有什么方法函数等等,只要碰到不会的或者不知道这个类里面有什么东西。
什么是模块
模块就是一个 .py文件,一个程序可以包含很多个模块,每个模块里面又包含很多的函数语句等,就是我们所写的代码,都是放在一个模块当中。
有两种方法导入
③然后我在文件夹中新写一个加法模块,名字叫calt
④然后我在同一文件夹中导入该模块,然后使用该模块的jisuan函数
包的导入方式有很多,理解了前面的import和from…怎么导入的就基本懂了。
就是一个层层递进一层剥一层的感觉。
示例代码如下:仅仅代表一小部分
#表示导入了包中的一个模块
import package1.packmd1
#表示导入了整个包
import package1
#可以通过包名直接调用一个模块中的pr1函数
package1.packmd1.pr1()
#可以先导入包中的函数
from package1 import packmf2
#然后就不用老是写包名才能调用到模块函数
packmf2.pr2()
#表示打开文件名问a的txt文件,打开方式为r只读
file = open('a.txt','r')
print(file.readline())
#打开了文件流就关闭文件流
file.close()
我们下面都已txt文件作为文件打开
src=open('xxx.jpg','rb')
target=open('jpgcopy.jpg','wb')
#这一条语句是边读边写的意思
target.write(src.read())
src.close()#记得关闭文件流
with open('66.txt','r') as file:
print(file.read())
#就是说有了该语句就不用手动关闭文件流了
执行过程
该语句意思是:首先进入打开文件流,然后执行读取或者写入操作等,然后不用手动使用close进行关闭文件流。
更深的理解
就是当我创建一个类对象的时候,并且使用对象调用方法的时候是先进入类,然后调用方法,然后退出类。
类中有两个进入和退出函数方法,我们通过重写他们可以得到一些信息
代码如下:
class SL(object):
def __enter__(self):
print('我进来啦!')
return self
def show(self):
print('我真在执行嚯~')
return
def __exit__(self, exc_type, exc_val, exc_tb):
print('我走咯~')
return
with SL() as s:
s.show()
为什么说重要呢,因为这与我们电脑操作系统直接相关联。
该模块中的函数能直接执行我们的可执行文件和系统中自带的系统
能写到这,让我明白了,时代在与时俱进,计算机科学更是如此,甚至更快,对于Python这门语言,我的感受是:它是C的儿子,是C#的偷懒兄弟,没有什么语言框架约束,拿来就能用。手持Pycharm,懂点英文就可以写代码了。
散功完毕~
愿各位道友日后注意身体健康,有了健康方能走得更远,修为方能更进一步。