Python语法基础（二）+面向对象基础

语法基础

一.字符串

1.字符串的常用操作

python 复制代码

s1='Helloworld'
new_s2=s1.lower()#将所有内容转成小写
print(new_s2)
s2='dfjk@sddf.fgg'
lst=s2.split('@')#以@作为分隔符
print(lst[0],lst[1])
s3='fdsfjdslv'
print(s3.find('o'))#find会输出-1
print(s3.index('o'))#index如果没有找到的话会报错
s4='demo.py'
print(s4.endswith('.py'))#判断是否以.py结尾的

2.格式化字符串

格式化字符串的三种形式

python 复制代码

name='lsc'
age=19
score=91.4
print('姓名%s,年龄%d,成绩%.1f'%(name,age,score))
print(f'姓名{name},年龄{age},成绩{score}')
print('姓名{0}，年龄{1}，成绩{2}'.format(name,age,score))
print('姓名{1}，年龄{2}，成绩{0}'.format(score,name,age))

3.字符串的编码和解码

python 复制代码

s='我爱说实话'
scode=s.encode('utf-8',errors='replace')#转码过程
print(scode)
str=scode.decode('utf-8',errors='replace')#解码过程
print(str)

4.数据的验证

5.字符串的拼接和去重

字符串的拼接可以使用str.join()进行拼接，也可以直接拼接，还可以使用格式化字符串进行拼接

python 复制代码

#直接拼接
print('hello''world')#输出结果helloworld
#格式化字符串拼接
s1='hello'
s2='world'
print('%s%s' %(s1,s2))
print('{0}{1}'.format(s1,s2))
print(f'{s1}{s2}')#都输出helloworld
#+进行拼接
print(s1+s2)
#join()函数进行拼接
print('*'.join([s1,s2]))#输出的是hello*world，
# 中间用*连接起来,也可以是空字符串等任意字符

字符串的去重可以使用in或者not in来进行判断，或者通过集合去重

python 复制代码

s='helloworjnfdfv'
new_s=''
for item in s:
    if item not in new_s:
        new_s+=item
print(new_s)
new_s2=''
for i in range(len(s)):
    if s[i] not in new_s2:
        new_s2+=s[i]
print(new_s2)
new_s3=set(s)
lst=list(new_s3)
lst.sort(key=s.index)
print(''.join(lst))

6.正则表达式

二.Pyhton中的异常处理

1.try-else语句

2.raise关键字

python 复制代码

try:
    gender=input('您的性别是')
    if gender!='男'and gender!= '女':
        raise Exception('性别只能为男或女')
    else:
        print('性别是',gender)
except Exception as e:
    print(e)

3.Python中常见的异常

三.函数

1.函数的定义

函数是将一段实现功能的完整代码，使用函数名进行封装，通过函数名称进行调用，以此达到一次编写，多次调用的目的。

python 复制代码

def get_sum(num):
    s=0
    for i in range(1,num+1):
        s+=i
    print(f'累加和是',s)

#函数调用
get_sum(10)

2.函数的参数传递

如果既有位置传参，又有关键字传参，那么要位置传参在前，关键字传参在后

当位置参数和默认值参数同时存在时，要遵循位置参数在前，默认值参数在后的规则，否则会报错

python 复制代码

def happy_birthday(name,age):
    print('祝'+name+'生日快乐')
    print(str(age)+'生日快乐')
happy_birthday('lsc',18)#位置传参
happy_birthday(age=18,name='lsc')#关键字传参
def pass_exam(name='lsc',age=18):
    print('祝' + name + '考试顺利')
pass_exam()#采用默认值进行传值

个数可变的位置参数

python 复制代码

def fun(*para):
    for i in para:
        print(i)
fun(10,20,30,40)
fun([10,20,30,40])#实际上传入的是一个列表类型，只有一个参数（列表）
fun(*[10,20,30,40])#可以对列表进行解包，让每个数据单独输出

个数可变的关键字参数

python 复制代码

def fun2(**para):
    for key,value in para.items():
        print(key,value)
fun2(name='lsc',weight=70,height=180)#个数可变的关键字传参
d={'name':'lsc','weight':70,'height':180}#如果参数是个字典，那么前面要加两颗星进行解包
fun2(**d)

3.函数的返回值

python 复制代码

def get_sum(n):
    s=0
    odd_sum=0
    even_sum=0
    for i in range(1,n):
        if(i%2!=0):
            odd_sum+=i
        else:
            even_sum+=i
        s+=i;
    return odd_sum,even_sum,s
print(get_sum(10))
print(type(get_sum(10)))#类型是元组类型
#还可以进行解包赋值
a,b,c=get_sum(10)
print(a)
print(b)
print(c)

4.变量的作用域

局部变量和全局变量，当两者的名称相同时，局部变量的优先级较高

如果在函数中定义了一个局部变量，但是使用了global关键字来定义变量(注意赋值和声明要分开来做)，那么这个变量就成为了一个局部变量

5.匿名函数lambda

6.递归

7.常用的内置函数

python 复制代码

lst=[10,4,76,88,32,49]
new_lst=sorted(lst)#升序
print(new_lst)
new_lst2=sorted(lst,reverse=True)#降序
print(new_lst2)
new_lst3=reversed(lst)#翻转
print(list(new_lst3))
x=['a','b','c','d']
y=[10,20,30,40,50]
zipobj=zip(x,y)
print(list(zipobj))
def fun(num):
    return num%2==1
w=[1,2,3,4,5,6,7,8,9,10]
obj=filter(fun,w)#filter按照指定条件进行筛选(筛选奇数)
print(list(obj))

面向对象编程

一.类和对象

1.定义类和创建自定义类

类可以看做是一个模版，而对象是具体的实例

python 复制代码

class student:
    #类属性，定义在类中，方法外的变量
    school='工业大学'
    #初始化方法
    def __init__(self,xm,age):#xm,nl是形式参数，作用域是整个init函数
        self.name=xm#左侧是实例属性，右侧是局部变量，相当于一个赋值的操作
        self.age=age#形参和实例属性的名称可以相同

    def show(self):#定义在类中的函数，称为方法，自带一个参数self
        print(f'名字{self.name}，年龄{self.age}')
    @staticmethod
    def sk():
        print('这是一个静态方法，不能使用实例的属性和方法')
    @classmethod
    def hm(cls):
        print('这是一个类方法，同样不能使用实例的属性和方法')
stu=student('lsc',18)
print(stu.name,stu.age)#实例属性用对象名加打点来表示
print(student.school)#类属性直接用类名打点来表示
stu.show()
student.hm()#类方法直接使用类名加打点的形式进行调用
student.sk()#静态方法直接使用类名加打点的形式进行调用

2.动态绑定属性和方法

（一）每个对象的属性名称相同，但属性值不同

（二）可以为某个对象绑定独有的属性或方法

python 复制代码

class student:
    #类属性，定义在类中，方法外的变量
    school='工业大学'
    #初始化方法
    def __init__(self,xm,age):#xm,nl是形式参数，作用域是整个init函数
        self.name=xm#左侧是实例属性，右侧是局部变量，相当于一个赋值的操作
        self.age=age#形参和实例属性的名称可以相同

    def show(self):#定义在类中的函数，称为方法，自带一个参数self
        print(f'名字{self.name}，年龄{self.age}')
stu1=student('lsc',18)
stu2=student('xxx',20)
stu1.gender='男'#为stu1动态绑定了一个属性gender
print(stu1.name,stu1.age,stu1.gender)
def introduce():
    print("被动态绑定到stu2")
stu2.fun=introduce#注意这里是函数的赋值，相当于动态绑定，不能加小括号
stu2.fun()#这才是函数的调用

二.面向对象的三大特征（封装，多态，继承）

1.权限控制

python 复制代码

class student():#小括号加不加都可以
    def __init__(self,name,age,gender):
        self._name=name #self._name受保护，只能本类和子类去访问
        self.__age=age #代表私有的，只能类本身去访问
        self.gender=gender#代表是公有的，谁都可以访问
    def _fun1(self):
        print("子类或本身可以访问")
    def __fun2(self):
        print("只有定义的类可以访问")
    def show(self):
        self._fun1()
        self.__fun2()
        print(self._name)
        print(self.__age)
stu=student('lsc',18,'男')
print(stu._name)#受保护的类型也可以在外部进行访问
stu._fun1()#受保护的类型也可以在外部进行访问
print(stu._student__age)#私有的类型也可以访问，采用左边这种形式即可
stu._student__fun2()#私有的类型也可以访问，采用左边这种形式即可

2.属性设置

python 复制代码

class student:
    def __init__(self,name,gender):
        self.name=name
        self.__gender=gender
    #现在gender不能被访问，可以设置一个方法，把方法转换成属性去使用
    @property #设置的方法，把方法转换成属性去使用
    def gender(self):
        return self.__gender
    @gender.setter #如果想改的话，只能用setter来进行修改
    def gender(self,value):
        self.__gender=value
stu=student('lsc','男')
print(stu.gender)#stu.gender就会执行stu.gender()，但是只能看不能改

3.继承

python 复制代码

class person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def show(self):
        print(f'名字是{self.name},年龄是{self.age}')
class student(person):
    def __init__(self,name,age,stuno):
        super().__init__(name,age) #调用父类的初始化方法,name和age采用父类的数值
        self.stuno=stuno
stu=student('lsc','18','107')

在多继承中，一个父类可以有若干个子类，一个子类也可以有多个父类

python 复制代码

class fatherA():
    def __init__(self,name):
        self.name=name
    def showA(self):
        print('父类A中的方法')
class fatherB():
    def __init__(self,age):
        self.age=age
    def showB(self):
        print('父类B中的方法')
class son(fatherA,fatherB):
    def __init__(self,name,age,gender):
        fatherA.__init__(self,name)
        fatherB.__init__(self,age)
        self.gender=gender
Son=son('lsc',18,'男')
print(f'{Son.name},{Son.age},{Son.gender}')
Son.showB()
Son.showA()

4.方法重写

python 复制代码

class fatherA():
    def __init__(self,name):
        self.name=name
    def showA(self):
        print(f'父类A中的名字{self.name}')
class fatherB():
    def __init__(self,age):
        self.age=age
    def showB(self):
        print(f'父类B中的年龄{self.age}')
class son(fatherA,fatherB):
    def __init__(self,name,age,gender):
        fatherA.__init__(self,name)
        fatherB.__init__(self,age)
        self.gender=gender
    def showA(self):
        fatherA.showA(self)#如果存在多继承，可以直接通过调用父类的名字
        print(f'性别为{self.gender}')
Son=son('lsc',18,'男')
Son.showA()
#运行结果为 父类A中的名字lsc  性别男

5.多态

python 复制代码

class person():
    def show(self):
        print('这是人')
class cat():
    def show(self):
        print('这是猫')
#这两个类中都有一个同名的方法show()函数
def fun(obj):#obj是函数的形式参数，在这里还不知道调用哪个方法
    obj.show()
per=person()
Cat=cat()
#在程序运行时动态调用，只要不同的类中有同名的方法，就可以实现多态
fun(per)#输出：这是人
fun(Cat)#输出：这是猫

6.object类

是所有类直接或间接的父类，所有类都拥有object类的属性和方法

在创建对象的过程中，先执行__new__()函数，再执行__init__()函数

7.类的特殊属性

python 复制代码

class A():
    pass
class B():
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age
print(A.__base__)
print(B.__base__)
print(C.__base__)#base如果有多个父类，只会继承第一个父类
print(C.__bases__)#bases显示该类的父类的元组

8.深拷贝与浅拷贝

变量的赋值只是将原来变量的内存地址拷贝了一份给它，并没有开辟新的空间，也就是所说的两个变量指向同一个对象

浅拷贝将要拷贝的对象开辟了一块新的空间，但是两者的子对象还是同一个，也就是说，他们的内存还是指向同一块，只不过拷贝的父类对象的内存地址发生了改变。

深拷贝则使用deepcopy函数。将父类对象和其子类对象都开辟一块新的内存，因此深拷贝后的对象无论是父类还是子类的内存地址都与原来的不相同。