Python学习笔记——Python基础知识

基础语法

#单分支结构
if score>=60 and score<=100:
    print('及格')
    
#双分支结构
if score>=60 and score<=100:
    print('及格')
else:
	print('不及格')
    
#多分支结构
if score>=60 and score<=80:
	print('良好')
elif score>=80 and score<=100:
    print('优秀')
else:
    print('不及格')
    
#条件表达式		(情况1)	if 表达式 else	 (情况2)	为Ture执行情况1,False执行情况2
print( ('a大于b')	if a>b else	('a不大于b') )

#pass:是一个占位符,只用来临时占位
if(res>100):
    pass
else:
    pass

循环体

while循环

语法结构：while 条件(为True):

​ 循环体

for-in循环

语法结构：for 自定义的变量 in 可迭代对象:

​ 循环体

#循环遍历字符串
for item in 'Python':
    print(item)
#循环遍历整数序列
for i in range(10):
    print(i)
#如果不需要自定义变量,可以写为将其写为_
for _ in range(5):
    print('循环五次')

转义符

#\n			换行符
print('hello\nworld')	

#\t			制表符,占四个字符
print('hello\tworld')	#>hello    world

#\r			回车符
print('hello\rworld')	#>world

#\b			退格符,退回上一个字符
print('hello\bworld')	#>hellworld

#使转义符失效(最后一个字符不能是单个反斜杠)
print(r'hello\nworld')	#>hello\nworld
print(r'hello\nworld\')	#报错

运算符

常用运算符

#加减乘除：+、-、*、/

特殊运算符

整除：//（一正一负向下取整） 11//2 >>> 5 9//-4 >>> -3

取余：%（一正一负：结果=被除数-除数*商） 11%2 >>> 1

幂运算：** 2**3 >>> 8

赋值运算符

#解包赋值：交换a和b的值
a,b,c = 20,30,40
a,b = b,a		#a=30,b=20

比较运算符

a = 10
b = 10
list1 = [11,22,33,44]
list2 = [11,22,33,44]
#==:比较对象的值
print(a==b)		#True
#is/is not:比较对象的地址
print(a is b)	#Ture
print(list1 is list2)		#False
print(list1 is not list2)	#True

布尔运算符

#and:与
#or:或
#not:非
#in:被包含于
str = 'Hello'
print('H' in str)		#True
print('A' in str)		#False
#not in:不被包含于
print('A' not in str)	#True

注释

单行注释

# 以#开头，直到换行结束
# 单行注释

多行注释

#以一对三引号作为开始和结束

''' 这里是
多行
注释'''

中文编码声明注释

#在.py文件开头加入，用以指定文件的编码格式
#coding:gbk		指定为GBK编码

列表

特点：

创建

#创建列表对象
#方式一:直接赋值
list1 = ['hello','world',123]
#方式二:使用list()函数
list2 = list(['hello','world',123])
#创建空列表
list3 = []
list4 = list()

查询

list = ['hello','world',123,'hello',888,'wang',666,333]

#获取列表中的单个元素
a = list[1]
print(a)				# world

#获取列表中的多个元素
list2 = list[1:6:1]			# [起始位置:结束位置(不包含):步长] 默认步长为1
print(list2)				# ['world',123,'hello',888,'wang']
#步长为负数时逆序输出
list3 = list[::-1]
print(list3)				# [333,666,'wang',888,'hello',123,'world','hello']

#获取列表中的元素索引:使用index()函数
print(list.index('hello'))				# 0,如果有相同元素只返回第一个的索引
print(list.index('Python'))				# ValueError:'Python' is not in list
#在指定范围内查找元素
print(list.index('hello'),1,4)			# 3

'''判断指定元素在列表中是否存在
元素 in/not in 列表名'''
print('hello' in list)		#True
print(222 not in list)		#True			

增加

list1 = [10,20,30]
list2 = [50,60]

# append():在列表的末尾添加一个元素
list1.append(40)
print(list1)			#[10,20,30,40]
#list1.append(list2)	 
#print(list1)			 [10,20,30,40,[50,60]] 将list2视为一个元素

# extend():在列表的末尾添加至少一个元素
list1.extend(list2)		
print(list1)			#[10,20,30,40,50,60] 将list2中的元素拆开来

# insert(index,i):在列表的任意位置添加一个元素
list1.insert(1,999)
print(list1)			#[10,999,20,30,40,50,60]

# 切片:在列表的任意位置添加至少一个元素
list3 = [True,False,'hello']
list1[1:] = list3		#将list[1]后面的元素用list3替换
print(list1)			#[10,True,False,'hellow']

删除

# remove(i):删除指定元素,如果有重复元素只删除第一个
# pop(index):删除指定索引位置上的元素,如果不指定索引则删除最后一个元素
# 切片:一次至少删除一个元素
list1[1,3] = []			#实际上是使用空列表替换其中某些元素
# clear():清空列表
# del:删除列表
del list1

修改

list1 = [10,20,30,40]

#一次修改一个值
list1[2] = 300
print(list1)			#[10,20,300,40]

#一次修改多个值
list1[1:3] = [200,300,400,500]
print(list1)			#[10,200,300,400,500,40]

遍历

#列表元素的遍历
for item in list:
    print(item)	

排序

list1 = [10,30,20,60,50]
#升序排序:sort()
list1.sort()
#list1.sort(reverse = False)
print(list1)			#[10,20,30,50,60]
#降序排序
list1.sort(reverse = True)
print(list1)			#[60,50,30,20,10]

#使用内置函数sorted()对列表进行排序,将产生一个新的列表对象
new_list1 = sorted(list1,reverse = False)	#升序
new_list2 = sorted(list1,reverse = True)	#降序

列表生成式

#语法格式:[表示列表元素的表达式 for 自定义变量 in 可迭代对象]	表达式中通常包含自定义变量
list = [i*i for i in range(1,6)]
print(list)			#[1,4,9,16,25]

字典

相当于 HashMap

• Python 内置的数据结构之一，与列表一样是一个可变序列
• 以键值对的方式存储数据，是一个无序的序列

创建

#方式一:使用{}
dictionary = {'k1':1,'k2':2}
#方式二:使用内置函数dict()
dictionary2 = dict(name='tom',age=20)
#创建空字典
dic = {}
dic2 = dict()

查询

score = {'zs':100,'ls':80}
#查找的键不存在时,方式一会报错,方式二不报错(返回None)
#方式一:使用[]
print(score['zs'])			#100
#方式二:使用get()方法
print(score.get('zs'))		#100

增加

#增加键值对
score['ww'] = 90

删除

#删除指定键值对
del score['zs']
#清空字典
score.clear()

修改

#修改元素
score['ww'] = 100

遍历

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

其他

#获取所有的key,类型为列表
keys = score.keys()
#获取所有的value,类型为列表
values = score.values()
#获取所有键值对,类型为列表,列表中存储元组
kv = score.items()

字典生成式

items = ['fruits','books','others']
prices = ['苹果','《三体》',100]
#使用内置zip()函数
dictionary = {item:price for item,price in zip(items,prices)}

元组

• python 内置的数据结构之一，是一个不可变序列

创建

#方式一:使用()创建,()可以省略
t1 = ('python','world',99)
t11 = 'python','world',99
#方式二:使用内置函数tuple()
t2 = tuple(('python','world',99))
#创建只有一个元素的元组必须使用逗号和小括号
t3 = ('python',)
#创建空元组
t4 = ()
t5 = tuple()

遍历

t = ('python','world',98)
for item in t:
    print(t[item])

集合

• 与列表、字典一样都属于可变序列
• 是没有 value 的字典，集合中的元素无序存储，不能重复

创建

#方式一:使用{}创建
s1 = {1,2,3,4,5,5,6,7,7}
print(s1)				#{1,2,3,4,5,6,7}
#方式二:使用内置函数set()
s2 = set(range(5))

增加

s = {1,2,3,4,5}
#添加一个元素
s.add(10)
#添加多个元素
s.update({7,8,9})

删除

s.remove(10)
s.remove(100)			#抛异常
s.discard(5)
s.discard(100)			#不抛异常
s.pop()					#随机删除一个元素
s.clear()				#清空集合

集合间的关系

#一个集合是否是另一个集合的子集
print(s1.issubset(s2))
#一个集合是否是另一个集合的超集
print(s1.issuperset(s2))
#两个集合是否没有交集
print(s1.isdisjoint(s2))

数学操作

s1 = {10,20,30,40}
s2 = {30,40,50,60}
#交集
print(s1.intersection(s2))			#{30,40}
print(s1 & s2)
#并集
print(s1.union(s2))					#{10,20,30,40,50,60}
print(s1 | s2)
#差集(s1 - s2)
print(s1.difference(s2))			#{10,20}
print(s1 - s2)
#对称差集
print(s1.symmetric_difference(s2))	#{10,20,50,60}
print(s1 ^ s2)

集合生成式

s = {i*i for i in range(6)}

数据结构总结

数据结构	是否可变	是否重复	是否有序	定义符号
列表（list）	可变	可重复	有序	[]
元组（tuple）	不可变	可重复	有序	()
字典（dict）	可变	key不可重复，value可重复	无序	{key:value}
集合（set）	可变	可重复	无序	{}

可变类型：value（值）改变，id（内存地址）不会改变

不可变类型：value（值）改变，id（内存地址）也会改变（创建了新的内存空间）

字符串

查询

#index(substr):查找子串第一次出现的位置,如果不存在就抛出异常
#rindex(substr):查找子串最后一次出现的位置,如果不存在就抛出异常
#find(substr):查找子串第一次出现的位置,如果不存在就返回-1
#rfind(substr):查找子串最后一次出现的位置,如果不存在就返回-1
#建议使用find方法

大小写转换

#upper():把字符串中所有字符都转成大写字母
#lower():把字符串中所有字符都转成小写字母
#swapcase():把字符串中所有大写字母转成小写字母,所有小写字母转成大写字母
#capitalize():把第一个字符转换为大写,其余字符转换为小写
#title():把每个单词的第一个字符转换为大写,每个单词剩余的字符转换成小写
#转换之后会产生一个新的字符串对象

内容对齐

#center(width,str):居中对齐,第一个参数指定宽度,第二个参数指定填充符,默认为空格,如果设置宽度小于实际宽度则返回原字符串
#ljust(width,str):左对齐,第一个参数指定宽度,第二个参数指定填充符,默认为空格,如果设置宽度小于实际宽度则返回原字符串
#rjust(width,str):右对齐,第一个参数指定宽度,第二个参数指定填充符,默认为空格,如果设置宽度小于实际宽度则返回原字符串
#zfill(width):右对齐,左边用0填充,只接收一个参数用于指定字符串的宽度,如果指定的宽度小于实际宽度则返回原字符串

字符串拆分

#split(str,maxsplit):从字符串左边开始拆分,可以用str指定拆分符,默认拆分字符是空格,返回值是一个列表;可以通过maxsplit指定拆分字符串的最大次数,在达到最大拆分次数后剩余的字符会作为单独的一部分
#rsplit(str,maxsplit):从字符串右边开始拆分,可以用str指定拆分符,默认拆分字符是空格,返回值是一个列表;可以通过maxsplit指定拆分字符串的最大次数,在达到最大拆分次数后剩余的字符会作为单独的一部分

判断字符串

#isidentifier():判断指定字符串是不是合法的标识符
#isspace():判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表符）
#isalpha():判断指定的字符串是否全部由字母组成（中文也算）
#isdecimal():判断指定的字符串是否全部由十进制的数字组成
#isnumeric():判断指定的字符串是否全部由数字组成（中文数字、罗马数字也为True）
#isalnum():判断指定的字符串是否全部由字母和数字组成

字符串比较

#比较规则:首先比较两个字符串中的第一个字符,如果相等则继续比较下一个字符,依次比较下去,直到两个字符串的字符不相等或达到最大长度
#比较原理:两个以上字符进行比较时,比较的是其ordinal value（原始值）,调用内置函数ord()可以得到指定字符的原始值;与内置函数ord()对应的是内置函数chr()，调用chr(value)时指定ordinal value可以得到其对应的字符

字符串切片

#[start:end:step]:从下标start开始,截取到end（不包括end）,步长为step

字符串替换/合并

#replace(str,newStr,maxReplace):第一个参数指定被替换的子串,第二个参数指定替换子串的字符串,第三个参数指定最大替换次数;该方法返回替换后得到的字符串,替换前的字符串不发生变化
#join(str):使用 str 将列表或元组中的字符串连接成一个新的字符串

⭐格式化字符串

#方式一:%做占位符
'''
%s:字符串
%i 或 %d:整数
%f:浮点数
'''
name = '张三'
age = '18'
money = '200.5'
print('我的名字叫%s,今年%d岁,有%f块钱' (name,age,money))		#我的名字叫张三,今年18岁,有200.5块钱

#方式二:{index}做占位符,index作为索引
print('我叫{0},今年{1}岁,我真的叫{0}'.format(name,age))		 #我叫张三,今年18岁,我真的叫张三

#方式三:f-string
print(f'我叫{name},今年{age}岁')			#我叫张三,今年18岁

#指定宽度和精度
print('%10d' %99)					#        99
print('%10.3f' %3.1415926)			#     3.142
print('{0:.3}'.format(3.1415926))	#3.14
print('{0:.3f}'.format(3.1415926))	#3.142

字符串的编码转换

s = '三国演义'
byte = s.encode(encoding = 'GBK')		#编码
s2 = byte.decode(encoding = 'GBK')		#解码

异常

常见异常类型

'''
ZeroDivisionError:除（或取模）0
IndexError:序列中没有此索引
KeyError:映射中没有这个键
NameError:未声明/初始化对象
SyntaxError:Python语法错误
ValueError:传入无效参数
'''

⭐异常处理机制

# try - except
try:
    代码块
except 异常类型:
    print('出错了')
    
# try - except - else:如果try块中没有抛出异常,则执行else块,如果try中抛出异常,则执行except块
try:
    n1 = int(input('请输入一个整数'))
    n2 = int(input('请输入另一个整数'))
    result = n1 / n2
except BaseException as e:
    print('出错了')
    print(e)
else:
    print('结果为:',result)
    
# try - except - else - finally:finally块无论是否发生异常都会被执行,一般用来释放资源
try:
    a = int(input('请输入一个整数'))
    b = int(input('请输入另一个整数'))
    result = a / b
except BaseException as e:
    print('出错了')
    print(e)
else:
    print('结果为:',result)
finally:
    print('谢谢您的使用')

打印异常信息

#使用traceback模块
import traceback
try:
    print('------------------')
    print(1/0)
except:
    traceback.print_exc()

函数

定义函数

def 函数名 (输入参数):
    函数体
    return xxx

def add(a,b):			#a,b为形参
    c = a + b
    return c

result = add(1,2)		#1,2为实参
print(result)			#3

#个数可变的位置形参
'''定义参数时,可能无法事先确定传递的位置实参的个数时,使用可变的位置形参（只能定义一个）
使用*定义个数可变的位置形参
结果为一个元组
'''
def fun1(*args):
    print(args)

fun1(10)				#(10,)
fun1(10,20,30)			#(10,20,30)

#个数可变的关键字形参
'''定义函数时,可能无法事先确定传递的关键字实参的个数时,使用可变的关键字形参（只能定义一个）
使用**定义个数可变的关键字形参
结果为一个字典
'''
def fun2(**args):
    print(args)

fun2(a=10)				#{'a':10}
fun2(a=10,b=20,c=30)	#{'a':10,'b':20,'c':30}

#在一个函数的定义中,既有个数可变的位置形参,也有个数可变的关键字形参时,要求位置形参在关键字形参之前

#函数内部声明的局部变量使用global关键字声明,就变成了全局变量
def fun3():
    global age
    age = 20

fun3()
print(age)		#20

常用内置函数

print()

print(100)				#输出数字
print(3+1)				#输出表达式
print('HelloWorld')		#输出字符串
print('hello','world')	#在同一行输出字符串

open()

#将数据输出到文件中
fp = open('D:/text.txt','a+')	#a+表示如果文件不存在就创建，存在就在文件内容的后面追加
print('HelloWorld',file = fp)	#将HelloWorld输出到D盘下的text.txt文件中

id()

#查看对象的内存地址
name = 'Alvis'
print('内存地址',id(name))	#内存地址 263393783782

type()

#查看对象的类型
name = 'Alvis'
print('类型',type(name))	#类型 <class 'str'>

str()

#将其他数据类型转成字符串
print(str(123))	#'123'

int()

#将其他数据类型转成整数,文字类和小数类字符串无法转换成整数
int('123')		#123
int(9.8)		#9
int('9.8')		#ValueError

float()

#将其他数据类型转成浮点数,文字类无法转换
float('9.9')	#9.9
float(9)		#9.0

input()

#输入函数,接收来自用户的输入,返回值为str类型(可以在输入时进行类型转换,输出时使用表达式)
res = input('结果是多少?')	 #控制台显示 结果是多少? 然后输入100
print(res)					#100

range()

#用于生成一个整数序列
#方式1:range(i)		i:数字个数
r = range(10)		#默认从0开始,步长为1
print(r)			#range(0,10)
print(list(r))		#[0,1,2,3,4,5,6,7,8,9]

#方式2:range(i,j)		i:起始值,j:到第j个数结束(不包含j)
r = range(1,10)		#默认步长为1
print(list(r))		#[1,2,3,4,5,6,7,8,9]

#方式3:range(i,j,k)	i:起始值,j:到第j个数结束(不包含j),k:步长
r = range(1,10,2)	
print(list(r))		#[1,3,5,7,9]

类与对象

​ Python是面向对象的语言，在Python中，一切皆对象

创建类

class Student:
    native_place = '北京'			#定义类属性
    
    #初始化方法（相当于Java中的构造方法）
    def __init__(self,name,age):
        self.name = name
        self.age = age
    
    #实例方法
    def study(self):
        print('学习')
        
    #类方法
    @classmethod
    def cm(cls):
        print('类方法')
        
    #静态方法
    @staticmethod
    def sm():
        print('静态方法')

创建对象

#创建Student类的对象
stu1 = Student('zs',20)
stu2 = Student('ls',22)
#调用类中的方法
stu1.study()				#学习
Student.study(stu1)			#学习

#动态绑定属性
stu1.gender = '男'
print(stu1.gender)			#男

#动态绑定方法
def show():
    print('定义在类外部的函数')
stu1.show = show
stu1.show()				#定义在类外部的函数
stu2.show()				#AttributeError

封装

#在类中定义外部访问不到的属性:使用两个下划线__
class BankAccount():
    def __init__(self,id,money):
        self.id = id
        self.__money = money		#私有属性,不能直接被外部访问
        
#可以用这种方法访问
acc = BankAccount('123456',500)
print(acc._BankAccount__money)		#500

继承

#语法为 class 类名(父类名):
#默认继承Object
#python支持多继承 class 类名(父类1,父类2):

#定义父类
class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
	def info(self):
        print('姓名{0},年龄{1}'.format(self.name,self.age))
#定义子类
class Student(Person):
    def __init__(self,name,age,score):
        super().__init__(name,age)
        self.score = score
        
stu = Student('zs',20,90)
stu.info()				#姓名zs,年龄20

#方法重写
class Teacher(Person):
    def __init__(self,name,age,teachYears):
        super().__init__(name,age)
        self.teachYears = teachYears
    def info(self):
        super().info()
        print('教龄{0}'.format(self.teachYears))

多态

class Animal():
    def eat(self):
        print('动物吃食物')

class Dog(Animal):
    def eat(self):
        print('狗吃肉')
        
class Cat(Animal):
    def eat(self):
        print('猫吃鱼')
        
class Person():
    def eat(self):
        print('人吃五谷杂粮')
        
def fun(animal):
    animal.eat()
    
fun(Dog())			#狗吃肉
fun(Cat())			#猫吃鱼
fun(Person())		#人吃五谷杂粮

浅拷贝

​ Python拷贝一般都是浅拷贝。拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象。

深拷贝

​ 使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同。

特殊属性

#__dict__:获得类对象或实例对象所绑定的所有属性和方法,存为字典
#__class__:获取对象所属的类
#__bases__:获取类的所有父类类型,存为元组
#__bases__:获取类的第一个父类类型
#__mro__:获取类的层次结构
#__subclasses__():获取类的所有子类，存为列表

特殊方法

#__add__():通过重写该方法,实现自定义对象类型的加法运算
#__len__():通过重写该方法,让内置函数len()的参数可以是自定义类型
Class Student:
    def __init__(self,name):
        self.name = name
    def __add__(self,other):
        return self.name + other.name
    def __len__(self):
        return len(self.name)
    
stu1 = Student('张三')
stu2 = Student('李四')
print(stu1 + stu2)		#张三李四

模块

​ 在Python中，一个.py文件就是一个模块（Module），模块可以包含函数、类和语句。

使用模块的好处：

1. 方便其他程序和脚本的导入并使用
2. 避免函数名和变量名冲突
3. 提高代码的可维护性
4. 提高代码的可重用性

创建模块

​ 新建一个.py文件，名称尽量不要与Python自带的标准模块重名。

导入模块

​ import 模块名称 [as 别名]

​ from 模块名称 import 函数/变量/类

PS：导入自定义模块前需要先将被导入模块所在目录设置为Sources Root

以主程序形式运行

#在每个模块的定义中都包括一个记录模块名称的变量__name__，程序可以检查该变量，以确定他们在哪个模块中执行。如果一个模块不是被导入到其他程序中执行，那么它可能在解释器的顶级模块中执行。顶级模块的__name__变量的值为__main__。
#可以在被导入模块中加入以下语句
if __name__ = '__main__':
    pass