lesson_

数值
Python数值分成了三种：整数、浮点数（小数）、复数

Python中的整数的大小没有限制，可以是一个无限大的整数

如果数字的长度过大，可以使用下划线作为分隔符

python 二进制表现形式 0b 开头 八进制表现形式 0o开头 十进制表现形式 0x开头

10进制的数字不能以0开头 其他进制的整数，只要是数字打印时一定是以十进制的形式显示的

只要带小数对python来说都是浮点数 以及浮点数相加会得到一个不精确的结果

字符串
单引号和双引号不能跨行使用

三重引号可以跨行，并且会保留字符串中的格式

可以使用 \ 作为转义字符，通过转义字符，可以在字符串中使用一些特殊的内容
\' 表示'
\" 表示"
\t 表示制表符
\n 表示换行符
\\ 表示反斜杠
\uxxxx 表示Unicode编码
1
2
3
4
5
6
7
b = 'hello %3.5s'%'abcdefg' # %3.5s字符串的长度限制在3-5之间
b = 'hello %s' % 123.456  #%s也可对应浮点数和整数
1
2
字符串 + 是拼接 *是 复制 -和/不行

布尔值和空值
布尔值实际上也属于整型，True就相当于1，False就相当于0
1
None（空值）
# None专门用来表示不存在
1
2
类型
整数 浮点数 字符串 None bool

转换

int(a) a不能是None 不能是非整数字符串如’yinsheng’ 不能是浮点数字符串如 ‘123.4’

float(a) 和int差不多

str(a) 啥都行

bool(a) 啥都行 0和None转化成的false

ps
int()函数不会对原来的变量产生影响，他是对象转换为指定的类型并将其作为返回值返回
# 如果希望修改原来的变量，则需要对变量进行重新赋值
1
2
3
运算符
1.算术运算符 + - * / //(整除) **(幂) %

2.赋值运算符 += -= /= //= %= *= **=

3.关系运算符 > >= < <= == is is not

关系运算符用来比较两个值之间的关系，总会返回一个布尔值
如果关系成立，返回True，否则返回False
result = 1 == True # True
result = 1 is True # False
result = 1 is not True # True
ps:
is 比较两个对象是否是同一个对象，比较的是对象的id
== 比较两个对象的值是否相等
1
2
3
4
5
6
7
8
result = 'ab' > 'b' # False
result = '2' > '11' # True
ps:
当对字符串进行比较时，实际上比较的是字符串的Unicode编码
比较两个字符串的Unicode编码时，是逐位比较的
且我发现 ord('A')  只能转个位字符串
1
2
3
4
5
6
4.逻辑运算符

and or not

and or  都是短路  比如and前面是false后面久不执行了  比如or前面是true后面就不执行了
非布尔值的与或运算  当我们对非布尔值进行与或运算时，Python会将其当做布尔值运算，最终会返回原值(主要看执行到哪一条语句  执行第一条就不执行了 则返回第一条语句的值)
not 对于非布尔值，运算会先将其转换为布尔值  然后进行运算
1
2
3
5.条件运算符

语句1 if 条件表达式 else 语句2

执行流程：
条件运算符在执行时，会先对条件表达式进行求值判断
如果判断结果为True，则执行语句1，并返回执行结果
如果判断结果为False，则执行语句2，并返回执行结果
1
2
3
4
运算符优先级

查表

流程控制语句
input函数返回的是字符串类型

if else

if elif else

while 条件表达式:

​ 语句

else:

​ 语句

修改元素 针对的是可变序列
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
stus[0:2] = ['牛魔王','红孩儿']
print(stus)  #['牛魔王','红孩儿','沙和尚','唐僧','蜘蛛精','白骨精']

stus[0:2] = ['牛魔王','红孩儿','二郎神']
print(stus) #['牛魔王','红孩儿','二郎神','沙和尚','唐僧','蜘蛛精','白骨精']

stus[0:0] = ['牛魔王'] 
print(stus)    #['牛魔王','牛魔王','红孩儿','二郎神','沙和尚','唐僧','蜘蛛精','白骨精']

stus[::2] = ['牛魔王','红孩儿','二郎神','加油']
print(stus) #['牛魔王','牛魔王','红孩儿','二郎神','二郎神','唐僧','加油','白骨精']

del stus[0:2]
print(stus)  #['红孩儿','二郎神','二郎神','唐僧','加油','白骨精']

del stus[::2]
print(stus)  #['二郎神','唐僧','白骨精']

stus[0] = '哈哈'
print(stus)    #['哈哈','唐僧','白骨精']

del stus[2] 
print(stus)    #['哈哈','唐僧']

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
函数参数
位置参数

默认参数

def fn(a = 5 , b = 10 , c = 20):
    print('a =',a)
    print('b =',b)
    print('c =',c)
fn(1 , 2 , 3)  #1   2   3
fn(1 , 2)    #1  2  20
fn()    #5   10   20

1
2
3
4
5
6
7
8
关键字参数 **

**形参可以接收其他的关键字参数，它会将这些参数统一保存到一个字典中，字典的key就是参数的名字，字典的value就是参数的值

**形参只能有一个，并且必须写在所有参数的最后

def fn3(b,c,**a) :
    print('a =',a,type(a))
    print('b =',b)
    print('c =',c)
fn3(1,2,k=5,w=6)
#a = {'k': 5, 'w': 6} <class 'dict'>
#b = 1
#c = 2
1
2
3
4
5
6
7
8
可变参数 *

可变参数不是必须写在最后，但是注意，带*的参数后的所有参数，必须以关键字参数的形式传递

如果在形参的开头直接写一个*,则要求我们的所有的参数必须以关键字参数的形式传递

*形参只能接收位置参数，而不能接收关键字参数

def fn2(*a,b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)
fn2(1,b=2,c=3)

def fn2(a,*b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)
fn2(1,2,c=3)

def fn3(*a) :
    print('a =',a)
fn3(1,2,3,4)
fn3(b=1)  #错误

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
高阶函数
高阶函数(

1.参数是函数 体现为map filtter 等等

2.返回值是函数 体现为闭包 闭包呢又可以导致出装饰器

)

zip 和 dict list 的结合

类方法和实例方法
实例方法
在类中定义，以self为第一个参数的方法都是实例方法
实例方法在调用时，Python会将调用对象作为self传入 
实例方法可以通过实例和类去调用
当通过实例调用时，会自动将当前调用对象作为self传入
当通过类调用时，不会自动传递self，此时我们必须手动传递self
1
2
3
4
5
6
类方法    
在类内部使用 @classmethod 来修饰的方法属于类方法
类方法的第一个参数是cls，也会被自动传递，cls就是当前的类对象
类方法和实例方法的区别，实例方法的第一个参数是self，而类方法的第一个参数是cls
1
2
3
4
实例方法当通过类调用时，不会自动传递self，此时我们必须手动传递self

类方法可以通过类去调用，也可以通过实例调用，没有区别

例子

class A(object):
    def test(self):
        print('这是test方法~~~ ' , self)
    @classmethod
    def test_2(cls):
        print('这是test_2方法，他是一个类方法~~~ ',cls)
        print(cls.count)
       
       
a = A()
a.test() 等价于 A.test(a)
A.test_2() 等价于 a.test_2()
1
2
3
4
5
6
7
8
9
10
11
12
json是字典的字符串的格式，两种可以相互转换

内置函数
find count index isalpha、isdigit、isspace pow abs

字符串 find count （ps xx.find(‘寻找的字符串’,start,end) 返回找到的第一个下标位置 没有找到则返回-1）

(ps xx.count(‘寻找的字符串’) 返回对应数量)

join(ps ‘按啥分隔’.join(xx) xx 可以是字符串 列表 元组)

a = '123456'  #也可以是列表或元组
b = ' '.join(a)
print([b])  #['1 2 3 4 5 6']
print(type(b)) #<class 'str'>
1
2
3
4
round()

eval()

# a = ' 3 * 7 '
# print(eval(a))  #21
————————————————
版权声明：本文为CSDN博主「BRAVE_Fighting」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/shijianzhihai/article/details/126682302