字符串

1.字符串介绍

字符串在python中是基本数据类型，是一个不可变的字符序列

2.字符串的驻留机制

仅保存一份相同且不可变字符串的方法,不同的值被存放在字符串的驻留池中,Python的驻留机制对相同的字符串只保留一份拷贝,后续创建相同字符串时,不会开辟新空间,而是把该字符串的地址赋给新创建的变量
驻留机制的几种情况（交互模式）

字符串的长度为0或1时
符合标识符的字符串
字符串只在编译时进行驻留，而非运行时
[-5, 256]之间的整数数字

sys中的intern方法强制2个字符串指向同一个对象

PyCharm对字符串进行了优化处理

字符串驻留机制的优缺点

当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是比较印象性能的。
在需要进行字符串拼接时建议使用str类型的join方法，而非 + ，因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new（创建）一次对象，效率要比使用“+”的效率高。

3.字符串的查询操作方法

index() 查找子串substr第一次出现的位置,如果查找的子串不存在时,则抛出ValueError

s='hello,hello'
print(s.index('lo'))    #输出3

rindex() 查找子串substr最后一次出现的位置,如果查找的子串不存在时,则抛出ValueError

s='hello,hello'
print(s.rindex('lo'))    #输出9

find() 查找子串substr第一次出现的位置,如果查找的子串不存在时,则返回-1

s='hello,hello'
print(s.find('lo'))    #输出3

4.字符串大小写转换方法

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

s='hello'
a=s.upper()
print(a)    #输出HELLO(a和s的地址不同，即产生一个新的字符串对象)

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

s='HeLLo'
a=s.lower()
print(a)    #输出hello

swapcase()把字符串中所有大写字母转换成小写字母，把所有小写字母转换成大写字母

s='HeLlo'
a=s.swapcase()
print(a)    #输出hElLO

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

s='hellO,pYthon'
a=s.capitalize()
print(a)    #输出Hello,python

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

s='HeLLO,pyThON'
a=s.title()
print(a)    #输出Hello,Python

5.字符串对齐

center()居中对齐,第1个参数指定宽度,第2个参数指定填充符,第2个参数是可选的,默认是空格,如果设置宽度小于实际宽度则返回原字符串
ljust()左对齐,第1个参数指定宽度,第2个参数指定填充符,第2个参数是可选的,默认是空格,如果设置宽度小于实际宽度则返回原字符串
rjust()右对齐,第1个参数指定宽度,第2个参数指定填充符,第2个参数是可选的,默认是空格,如果设置宽度小于实际宽度则返回原字符串
zfill()右对齐,左边用0填充,该方法只接收一个参数,用于指定字符串的宽度,如果指定的宽度小于等于字符串的长度,返回字符串本身

6.字符串劈分

'''split'''
s='hello world python'
lst=s.split()    #默认劈分符为空格
print(lst)    #输出['hello','world','python']
s1='hello|world|python'
print(s1.split(sep='|'))    #通过参数sep指定劈分字符串，输出['hello','world','python']
print(s1.split(sep='|',maxsplit=1))    #通过参数maxsplit指定劈分字符串时最大劈分次数，输出                                        ['hello','world|python']
'''rsplit'''
lst1=s.rsplit()
print(lst1)    #输出['hello','world','python']
print(s2.rsplit(sep='|'))    #输出['hello','world','python']
print(s2.rsplit(sep='|',maxsplit=1))    #输出['hello|world', 'python']

7.判断字符串操作的方法

isidentifier()判断指定的字符串是不是合法的标识符

s='hello,python'
print(s.isidentifier())    #False
print('hello'.isidentifier())    #True
print('张三_'.isidentifier())    #True

isspace()判断指定的字符串是否全部由空白字符组成(回车、换行、水平制表符)

print('\t'.isspace)    #True

isalpha()判断指定的字符串是否全部由字母组成
isdecimal()判断指定字符串是否全部由十进制的数字组成
isnumeric()判断指定的字符串是否全部由数字组成
isalnum()判断指定字符串是否全部由字母和数字组成

8.字符串的替换和合并

在这里插入图片描述

'''replace()'''
s='hello,python'
print(s.replace('python','java'))    #用java替换python，输出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
print('*'.join('python'))    #输出p*y*t*h*o*n

9.字符串的比较操作

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

比较规则 : 首先比较两个字符串中的第一个字符,如果相等则继续比较下一个字符,依次比较下去,直到两个字符串中的字符不相等时,其比较结果就是两个字符串的比较结果,两个字符串中的所有后续字符将不再被比较

比较原理 : 两上字符进行比较时,比较的是其ordinal value(原始值),调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr, 调用内置函数chr时指定ordinal value可以得到其对应的字符

print('apple'>'app')    #True
print('apple'>'banana')    #False

10.字符串的切片操作

字符串是不可变类型，切片将产生新的对象

s='hello,world'    #[start:end:step]
s1=s[0:5]    #第一个数字不写默认从零开始，第二个数字不写默认到最后结束
print(s1)    #s1为hello
s0='hello,python'
s2=s0[0:7:2]    #s2为hlop
s3=s0[::-1]    #s3为nohtyp,olleh
s4=s0[-6::1]    #s4为python

11.格式化字符串

在这里插入图片描述

'''%s占位符'''
name='张三'
age=30
print('我叫%s，今年%d岁' % (name,age))
'''{}占位符'''
print('我的名字叫{0}，我今年{1}岁，我真的叫{0}'.format(name,age))
'''f-string格式化'''
print(f'我叫{name}，今年{age}岁')
'''其他'''
print('%10d',99)    #10表示的是宽度
print('%.3f'%3.141592)    #四舍五入保留三位小数
print('%10.3f'%3.1415926)    #10为宽度，3为保留的小数点后位数
print('{0:.3}'.format(3.1415278))    #0为索引，3为保留位数（一共的位数），输出3.14
print('{0:.3f}'.format(3.1415278))    #.3f为保留三位小数
print('{0:10.3f}'.format(3.1415278))    #.3f为保留三位小数，10为宽度

12.字符串的编码与解码

编码

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

解码

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

函数

1.函数的定义与调用

'''创建'''
def    函数名([输入参数]):
    函数体
   [return xxx]
#例如：
def calc(a,b):
    c=a+b
    return c
#调用
result=calc(10,20)
print(result)

在这里插入图片描述

2.参数的传递

位置传参

def cala(a, b):    #a和b称为形式参数，简称形参，形参的位置是在函数定义处
    c = a + b
    return c
result=cala(10,20)    #10和20为实际参数的值，简称实参，实参的位置是函数调用处
print(result)

关键字传参

def cala(a, b):    #a和b称为形式参数，简称形参，形参的位置是在函数定义处
    c = a + b
    return c
result=cala(b=10,a=20)    #10和20为实际参数的值，简称实参，实参的位置是函数调用处
print(result)

3.函数的返回值

函数返回多个值时，结果为元组

def fun(num):
    odd=[]    #存奇数
    even=[]    #存偶数
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even
lst=[10,11,12,13,14,15]
print(fun(lst))    #输出([11, 13, 15], [10, 12, 14])

函数在定义时，是否需要返回值，视情况而定

4.函数参数的定义

函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参

def fun(a,b=10):
    print(a,b)
fun(100)    #只传一个参数，b采用默认值，输出100 10
fun(20,30)    #f30将默认值10替换，输出20 30

个数可变的位置参数：定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数;使用*定义个数可变的位置形参;结果为一个元组

def fun(*args):
    print(args)
fun(10)    #输出(10,)
fun(10,20,45,60)    #输出(10, 20, 45, 60)

个数可变的关键字形参：定义函数时，无法事先确定传递关键字的实参的个数时，使用可变的关键字形参;使用**定义个数可变的关键字形参;结果为一个字典

def fun(**args):
    print(args)
fun(a=10)    #输出{'a': 10}
fun(a=10,b=20,c=50)    #输出{'a': 10, 'b': 20, 'c': 50}

位置可变参数和关键字可变参数只能是一个

def fun(*args,*args1)    #会报错，因为个数可变参数只能有一个
    pass
def fun1(**args2,**args3)    #会报错，因为关键字可变参数只能有一个
    pass
def fun2(*args4,**args5)    #不会报错
    pass

5.变量的作用域

程序代码能访问该变量的区域

局部变量：在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就会就成全局变量

def fun(a,b):
    c=a+b    #c称为局部变量，因为c实在函数体捏进行定义的变量，a，b为函数的形参，作用范围也是函                #数内部，相当于局部变量
    print(c)
'''global声明为全局变量'''
def fun1():
    global age    #函数内部定义的变量，局部变量，局部变量使用global声明，这个变量就成了全局变量
    age=20
    print(age)

全局变量：函数体外定义的变量，可作用于函数内外

name='小朱'    #name的作用范围为函数内部和外部都可以使用，称为全局变量
print(name)
def fun():
    print(name)

6.递归函数

如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数

递归的组成部分有递归调用与递归终止条件

递归的调用过程：

每递归调用一次函数，都会在栈内存分配一个栈帧
每执行完一次函数，都会释放相应的空间

递归的优缺点：

缺点：占用内存多，效率低下
优点：思路和代码简单

'''递归计算阶乘'''
def fun(n):
    if n==1:
        return 1
    else:
        return n*fun(n-1)
print(fun(6))

BUG

1.Bug的常见类型

粗心导致的语法错误


'''1'''
age=input('请输入你的年龄：')    #input输入的都是str类型，需要强制类型转换
if age>=18
    print('成年人，做事需要负法律责任')
'''2'''
while i<10:    #没有给i赋值
    print（i）    #用了中文括号

漏了末尾的冒号，如if循环语句，else子句等

缩进错误，该缩进的不缩进，不该缩进的瞎缩进

把英文符号写成中文符号，比如引号、冒号、括号

字符串拼接的时候，把字符串和数字拼在一起

没有定义变量，比如while的循环条件的变量

“==”比较运算符和“=”赋值运算符的混用

2.被动掉坑

'''若除数为0，则程序将会报错：ZeroDivisionError'''
a=int(input('请输入一个整数'))
b=int(input('请输入一个整数'))
result=a/b
print('结果为:',result)
'''利用try-expect结构'''
try:
    a=int(input('请输入一个整数'))
    b=int(input('请输入一个整数'))
    result=a/b
    print('结果为:',result)
expect ZeroDivisionError:    #如果出现ZeroDivisionError错误将会执行以下语句
    print('除数不能为0')

可以采用try-expect-expect-expect.....结构，也可以采用try-expect-expect.......else结构

try:
    a=int(input('请输入一个整数'))
    b=int(input('请输入一个整数'))
    result=a/b
except ZeroDivisionError:    #如果出现ZeroDivisionError错误将会执行以下语句
    print('除数不能为0')
except ValueError:
    print('出错了')
else:
    print('结果为：',result)

try-except-except.....else-finally结构：

和上面的差不多，唯一不同的就是不论是否报错，finally块都会执行

python中常见的异常类型

序号	异常类型	描述
1	ZeroDivisionError	取（或取模）零（所有数据类型）
2	IndexError	序列中没有此索引（index）
3	KeyError	映射中没有这个键
4	NameError	未声明/初始化对象（没有属性）
5	SyntaError	python语法错误
6	ValueError	传入无效的参数

1.traceback模块的使用

import traceback
try:
    print('-----------')
    print(1/0)
except:
    traceback.print_exc()

在这里插入图片描述
输出的横线有时候在前，有时候在中，有时候在后。

类与对象

1.类与对象

类：类是多个类似事物组成的群体的统称。能够帮助我们快速理解和判断事物的性质

对象：100、99、520都是int类之下包含的类似的不同个例，这个个例专业术语称为实例或对象

2.类的创建

创建类的语法：

class Student:    
'''Student为类的名称，简称类名，由一个单词或多个单词组成，每个单词首字母大写，其余小写（不大写也可，不报错）'''
    pass

类的组成：类属性、实例方法、静态方法、类方法

class Student:
    native_pace='吉林'    #直接写在类里的变量，称为类属性
    def eat(self):  #实例方法，在类里面定义的称为方法，在类之外定义的叫函数
        print('学生在吃饭......')
    '''静态方法'''
    @staticmethod
    def method():   #静态方法不允许写self
        print('我使用了staticmethod进行修饰，所以我是静态方法')
    '''类方法'''
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')
    def __init__(self,name,age):
        self.name=name  #self称为实例属性，进行了一个叫赋值的操作，将局部变量的name的值赋给实例属性，self.后不一定非叫name，叫什么都可以，name只是一种习惯
        self.age=age

3.对象的创建

对象的创建又称为类的实例化

语法：实例名=类名()

#创建Student类的实例对象
stu=Student('Jack',20)
print(stu.name)    #实例属性
print(stu.age)    #实例属性
stu.info()    #实例方法

意义：有了实例，就可以调用类中的内容

class Student:
    native_pace='吉林'    #直接写在类里的变量，称为类属性
    def eat(self):  #实例方法，在类里面定义的称为方法，在类之外定义的叫函数
        print('学生在吃饭......')
    '''静态方法'''
    @staticmethod
    def method():   #静态方法不允许写self
        print('我使用了staticmethod进行修饰，所以我是静态方法')
    '''类方法'''
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')
    def __init__(self,name,age):
        self.name=name  #self称为实例属性，进行了一个叫赋值的操作，将局部变量的name的值赋给实例属性，self.后不一定非叫name，叫什么都可以，name只是一种习惯
        self.age=age
#创建Student类的对象
stu1=Student('张三',20)
stu1.eat()    #对象名.方法名
Student.eat(stu1)    #与上一行代码功能相同，都是调用Student中的eat方法
                   #类名.方法名（类的对象）-->实际上就是方法定义处的self
print(stu1.name)
print(stu1.age)

4.类属性

类属性：类中方法外的变量称为类属性，被该类的所有对象所共享

类方法：使用@classmethod修饰的的方法，使用类名直接访问的方法

静态方法：使用@staticmethod修饰的方法，使用类名直接访问的方法

class Student:
    native_pace='吉林'    #直接写在类里的变量，称为类属性
    def eat(self):  #实例方法，在类里面定义的称为方法，在类之外定义的叫函数
        print('学生在吃饭......')
    '''静态方法'''
    @staticmethod
    def method():   #静态方法不允许写self
        print('我使用了staticmethod进行修饰，所以我是静态方法')
    '''类方法'''
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')
    def __init__(self,name,age):
        self.name=name  #self称为实例属性，进行了一个叫赋值的操作，将局部变量的name的值赋给实例属性，self.后不一定非叫name，叫什么都可以，name只是一种习惯
        self.age=age
#类属性的使用方式
print(Student.native_pace)
stu1=Student('张三',20)
stu2=Student('李四',30)
print(stu1.native_pace) #输出吉林
print(stu2.native_pace) #输出吉林
Student.native_place='天津'
print(stu1.native_pace) #输出天津
print(stu2.native_pace) #输出天津
#类方法的使用方式
Student.cm()
#静态方法的使用方式
Student.method()

5.动态绑定属性和方法

python是动态语言，在创建对象之后可以动态的绑定属性和方法

class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def eat(self):
        print(self.name+'在吃饭')
stu1=Student('张三',20)
stu2=Student('李四',30)
#为stu2动态绑定性别属性
stu2.gender='女'
print(stu1.name,stu1.age)
print(stu2.name,stu2.age,stu2.gender)
'''为stu1绑定show函数'''
def show():
    print('定义在类之外的，称为函数')
stu1.show=show  #为stu1绑定了show函数
stu1.show()
stu2.show() #这行代码会报错，因为没有为stu2绑定show函数

python基础之字符串、函数、BUG和异常类型介绍及类和对象详细笔记

字符串

1.字符串介绍

2.字符串的驻留机制

字符串驻留机制的优缺点

3.字符串的查询操作方法

4.字符串大小写转换方法

5.字符串对齐

6.字符串劈分

7.判断字符串操作的方法

8.字符串的替换和合并

9.字符串的比较操作

10.字符串的切片操作

11.格式化字符串

12.字符串的编码与解码

函数

1.函数的定义与调用

2.参数的传递

3.函数的返回值

4.函数参数的定义

5.变量的作用域

6.递归函数

BUG

1.Bug的常见类型

2.被动掉坑

python中常见的异常类型

1.traceback模块的使用

类与对象

1.类与对象

2.类的创建

3.对象的创建

4.类属性

5.动态绑定属性和方法

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

python基础之字符串、函数、BUG和异常类型介绍及类和对象详细笔记

字符串

1.字符串介绍

2.字符串的驻留机制

字符串驻留机制的优缺点

3.字符串的查询操作方法

4.字符串大小写转换方法

5.字符串对齐

6.字符串劈分

7.判断字符串操作的方法

8.字符串的替换和合并

9.字符串的比较操作

10.字符串的切片操作

11.格式化字符串

12.字符串的编码与解码

函数

1.函数的定义与调用

2.参数的传递

3.函数的返回值

4.函数参数的定义

5.变量的作用域

6.递归函数

BUG

1.Bug的常见类型

2.被动掉坑

python中常见的异常类型

1.traceback模块的使用

类与对象

1.类与对象

2.类的创建

3.对象的创建

4.类属性

5.动态绑定属性和方法

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像