Python笔记
import random
a = random.randint(1, 3)
生成随机数字
#输出
print(100.5)
print('hellword')
print(4 + 5 - 3)
a = 4
print('hellword ', a)
print("hellword", 'hellPython')#不换行
#转移字符
print('hello00\tword', 'hello\n Python')
print('hello\rworld')#退一行
print('hello\bworld')#推一个字符
print('\\')
print(r'hell\nword')#原字符r/R
#ASII
print(chr(97))#ASII码
#变量
name = "李明"
print("标识", id(name))
print('类型', type(name))
print('返回值', name)
#数据类型
print(a, type(a))
print('十进制', 118)
print('二进制', 0b10110011)
print('八进制', 0o7777)
#浮点数
a = 1.1
b = 2.2
c = 1.5
print(a + b)#3.3000000000000003个别情况
print(a, type(a))
from decimal import Decimal
print(Decimal('1.1') + Decimal('2.2'))#decimal解决
print(Decimal(a) + Decimal(b))
print(a + c)
#布尔类型
f1 = True
f2 = False
print(f1, type(f1))
print(f2, type(f2))
#可以转化为整数运算
print(f1 + 1, f2 + 1)
#字符串 单引号 双引号 三引号
#单引号双引号只能在一行实现
str1 = 'Python'
str2 = "Pthon2"
str3 = '''Python
and c++'''
str4 = """Python
and c++"""
print(str1)
print(str2)
print(str3)
print(str4)
#类型转换函数int(), str()
name = '萧炎'
a = 20
print(type(a), type(name))
print('我'+'今年'+str(a)+',我叫'+name)
#int(), float(),str()
#注释与多行注释
'''
多行
注释
'''
#输入函数input
x = input('个头越大,叫的越响')
print(x, type(x))
a = int(input())
b = int(input())
print(a + b) #从输入的是字符类型,要使用转换变为int类型,或者在输入的时候直接设置输入的时候为int
#算数运算符
print(1 + 1)
print(1 - 1)
print(1 * 1)
print(1 / 1) #除法运算
print(11 // 5) #整除运算
print(11 % 5) #取余运算
print(2 ** 2) #2的2次方
print(2 ** 3) #2的3次方
print(9 // -4) #正和负数都是向下取整
#赋值运算符,从右到左运算
i = 3 + 4
print(i)
a = b = c = 20
print(a, b, c)
a += 30
a -= 10
print(a)
a *= 20
print(a)
a /= 3
print(a)
a //= 3
print(a, type(a))
a, b, c = 10, 20, 30
print(a, b, c) #解包赋值
a, b = b, a #交换
print(a, b)
#比较运算符
a, b = 10, 20
print(a > b)
print(a < b)
print(a == b)
a, b = a, a
print(id(a), id(b))
print(a is b)
#布尔类型 and or not in not in
a, b = 1, 2
print(a == 1 and b == 2)
print(a == 1 and b < 2)
print(a == 1 or b == 2)
print(not (a == 1))
str = 'helloworld'
print('w' in str)
print('k' in str)
print('wor' not in str)
print('kkk' not in str)
#位运算
print(4 & 8)
print(4 | 8)
print(1 >> 1)
print(1 << 1)
#对象的布尔值
print(bool(False))
print(bool(0))
print(bool(''))
print(bool(""))
print(bool([])) #空列表
print(bool(list())) #同上
print(bool(()))
print(bool(tuple())) #空元组
print(bool({}))
print(bool(dict()))#空字典
print(bool(set()))#空集合
#以上bool都为False
#分支结构
a = 10
b = 20
if a > b:
print('yes')
else:
print('no')
if a < 5:
print('a < 5')
elif a < 10:
print('a < 10')
elif a < 20 and b < 20:
print('a < 20 && b < 20')
else:
print(1)
#无括号, 有冒号
#嵌套if
a, b = 3, 2
if a == 1:
if b == 2:
print(a, b)
else:
print(b, a)
else:
print(b)
#条件表达式
a, b = 10, 20
print(str(a) + '大于等于' + str(b) if a >= b else str(a) + '小于' + str(b))#if如果为true,则执行前句,否则执行else
#pass语句 一个占位符
a = 10
if a != 10:
pass
else:
print('a == 10')
#range()函数创建
r = range(10) #只是指定长度,起始值从0开始到 n - 1
print(list(r)) #用于查看range对象中的整数序列
r = range(1, 10) #指定起始值到n - 1
print(list(r))
r = range(1, 10, 2) #指定起始值和数值间长度区别
print(list(r))
#判断指定整数在序列中是否存在
print(10 in r)
print(9 in r)
print(10 not in r)
#循环结构
a = 1
while a < 10:
a += 1
print(a)
#用空行来判断是否在while循环里
a += 2
print(a)
#for——in循环
for it in 'Python':#依次将字符串的每个字符取出
print(it)
for i in range(10):#range()一个整数序列,并依次输出
print(i)
for _ in range(5):#不需要变量则写为_
print('我是萧炎')
sum = 0
for i in range(1, 101):
if i % 2 == 0:
sum += i
print(sum)
#break
for i in range(3):
if i == 1: break
print(i)
#continue
for i in range(4):
if i % 2: continue#奇数舍去不输出
print(i)
#else 与while和for可以搭配使用,如果while和for中没有break,则会执行else语句
a = 1
for i in range(1, 10):
a += i
if(a > 100000): break
else:
print('a < 100000') #该语句执行
#嵌套循环
for i in range(1, 10):
for j in range(1, 10):
print('*', end = '\t') #\t 不换行输出
print()#换行
#列表/数组
lst1 = ['hello', 'hello', 'world', 99, 'hello']
lst2 = list(['hello', 'world', 99])
#两种方式如上
print(lst1, lst2)
print(lst1.index('hello')) #返回列表中元素的索引,有相同元素则返回第一个
print(lst1.index('hello', 1, 4)) #可以按照区间查找, 区间左闭右开
#索引
print(lst1[-2], lst2[1])
#获取切长
s1 = [10, 20, 30, 40, 50, 60, 70]
print('原列表', s1)
lst2 = s1[1 : 6 : 1] #start : end + 1 : 步长, 每一个都可以省略
print('lst2', lst2)
lst3 = s1[1 : 6]
print('lst3', lst3)
lst4 = s1[1 : 6 : 2]
print('lst4', lst4)
print(s1[::]) #全部省略后全部输出
print(s1[:: -1]) #-1后倒叙输出
#元素是否在列表中存在
print(10 in s1)
for i in s1:
print(i, end = ' ')
print()
#向列表的末尾增添一个元素
s1.append(80)
print(s1)
#向列表末尾添加许多元素
s1.extend(s1)
print(s1)
#在列表的任意位置插入元素
s1.insert(0, 90)
print(s1)
#在一个区间内切去一些元素并插入n个元素
s1[2 : 3] = [100, 100, 100]
print(s1) #左闭右开
#列表元素的删除操作
st1 = [10, 20, 30, 40, 50]
print(st1)
st1.remove(10) #删除列表中的第一个是10的元素
print(st1)
st1.pop(1) #根据索引移除元素
st1.pop() #不指定索引删除最后一个元素
print(st1)
st1.extend(st1)
'''产生一个新的列表'''
st = st1[1:3]
print(st, st1)
#删除其中一个片段
st1[1 : 3] = []
print(st1)
#清空列表
st1.clear()
print(st1)
#删除列表
del st1
#修改列表元素
st1 = [10, 20, 30, 40]
st1[2] = 100
print(st1)
st1[1 : 3] = [1, 1, 1, 1, 1, 1]
print(st1)
#列表的排序操作
print(st1)
st1.sort() #升序
print('排序后:', st1)
st1.sort(reverse = True) #降序
print('排序后', st1)
'''用sorted 进行产生新列表排序'''
List = sorted(st1)#升序
List0 = sorted(st1, reverse = True) #降序
print(List)
print(List0)
# 列表生成式
st1.clear()
st1 = [i * i for i in range(1, 10)]
print(st1)
#字典, 类似于c中的unordered_map
sorces = {'萧炎' : 99, '王五' : 10}
print(sorces)
print(type(sorces)) # 类型是dict
# 第二种dicti() 的创建方式
student = dict(name = 'jack', age = 100)
print(student)
#创建空字典
a = {}
print(a)
#获取字典元素
print(sorces['萧炎']) #如果索引不存在报错
print(sorces.get('萧炎')) #如果索引不存在返回None, 如下
print(sorces.get('1'))
#若索引不存在,则可以设置一个返回的默认值
print(sorces.get('1', -1)) # 输出-1
# 字典序的判断操作 in 和 not in
print('萧炎' in sorces)
print('萧炎' not in sorces)
# 字典元素的删除
del sorces['萧炎']
print(sorces)
sorces['xiaoyan'] = 99 #新增元素或者修改元素索引的value
print(sorces)
#清空字典元素
sorces.clear()
print(sorces)
#获取字典视图
s = {'Liming' : 3, 'Wangwu' : 5, 'Zeming' : 5}
#获取所有的key
keys = s.keys()
print(keys)
print(type(keys))
print(list(keys)) #将key转化为列表
#获取所有的value
values = s.values()
print(values)
print(type(values))
print(list(values))
#获取所有的key-value对
item = s.items()
print(item) #打印出来的是元组
print(list(item)) #列表元素由元组组成
# 元素的遍历
for items in s:
print(items, s[items], s.get(items))
#字典特点:1,key不可以重复,value可以 2.字典中的元素无序 3.key不可变 4.空间换取时间
#字典生成式
i = ['f', 'd', 'k']
j = ['1', '2', '3', '3']
d = {i : j for i, j in zip(i, j)} #借用zip内置函数让两个列表生成一个字典
print(d)
#元组: 没有增删改
#可变序列 列表, 字典
#不可变序列 字符串 元组
#创建方式
t = ('python', 'wordl', 98)
print(t)
print(type(t))
# 第二种使用tuple 内置函数
t1 = tuple(('Python', 'world', 98))
#元素中只有一个元素的时候需要加上一个逗号,否则为str类型
#空元组
t3 = ()
t4 = tuple()
d = []
d1 = list()
l = {'python' : 3}
l1 = dict()
print(t3, t4)
print(d1, d)
print(l, l1, type(l))
#元组的不可变序列
t = (10, [20, 30], 40)
#t[0] = 20 是不对的, 元组中的对象不可变
t[1].insert(1, 10)
print(t) #如果元组中的对象为可变序列, 则可以进行修改
#元组的遍历
for item in t:
print(item)
#集合 可变类型序列
s = {2, 2, 3, 3}
print(s, type(s))
#第二种创建方式
s1 = set(range(5))
print(s1)
for i in s1:
print(i)
s2 = set([1, 1, 2, 3, 3, 4, 4, 5])
print(s2)
s4 = set('Python')
print(s4) #无序性
s3 = set((1, 1, 2, 3))
print(s3)
#定义一个空集合
s6 = set()
print(type(s6))
#集合元素的判断
s = {10, 20, 30, 40, 50}
print(10 in s)
print(20 not in s)
print(100 in s)
#集合元素的增添
s.add(60)
print(s)
'''增添许多元素update'''
s.update({200, 300, 400})
print(s)
s.update([33, 34])
s.update((1, 2, 3, 4))
print(s)
'''集合元素的删除'''
s.remove(33) #指定元素必须在集合当中
s.discard(100) #指定元素可以不在集合当中
s.pop() #从前从后删除集合中的元素
s.pop()
print(s)
s.claer()
print(s)
#集合是否相等
s1 = {1, 2, 3, 4}
s2 = {4, 3, 2, 1}
print(s1==s2)
print(s1 != s2)
'''一个集合是否是另一个集合的子集'''
s1 = {10, 20, 30, 40}
s2 = {10, 20}
s3 = {10, 80}
print(s2.issubset(s1))
print(s3.issubset(s1))
'''一个集合是否是另一个集合的超集'''
print(s1.issuperset(s2))
print(s1.issuperset(s3))
'''两个集合是否有交集'''
s4 = {77}
print(s1.isdisjoint(s2))
print(s1.isdisjoint(s4))
'''有交集返回false, 无交集返回true'''
#集合的交集 并集 差集
'''交集'''
s1 = {10, 20, 30}
s2 = {20, 50, 100}
print(s1.intersection(s2))
print(s1 & s2)
#并集
print(s1.union(s2))
print(s1 | s2)
#差集
print(s1.difference(s2))
print(s1 - s2)
print(s2 - s1)
#对称差集
print(s1.symmetric_difference(s2))
print(s1 ^ s2)
#集合生成式
x = [i * i for i in range(1, 10)]
print(x)
y = {i * i for i in range(1, 10)}
print(y)
#字符串的创建与驻留机制
a = 'Python'
b = "Python"
c = '''Python'''
print(id(a))
print(id(b))
print(id(c))
#a, b, c的地址完全相同
a = ''.join(['abc'])
print(a)
#Python中用.join的运行效率比+要高
#字符串的查询操作
s = 'hello, hello'
print(s.index('lo'))
print(s.find('lo'))
print(s.rindex('lo'))
print(s.rfind('lo'))
print(s.find('k')) #如果寻找的子串在字符串中不存在, find返回-1, index报错
print(s.rfind('lk'))
s = 'hello world'
a = s.upper() #小写转大写
print(a)
b = a.lower() #大写转小写
print(b)
s = 'Hello World'
print(s)
c = s.swapcase() #大写转小写 小写转大写
print(c)
d = c.capitalize() #第一个字符转大写, 其他转小写
print(d)
f = d.title() #每个单词的第一个字符转大写, 其他小写
print(f)
#字符串对齐方法
s = 'hello.Python'
print(s.center(20, '*')) #居中对齐
print(s.center(20))
print(s.ljust(20, '*')) #左对齐
print(s.ljust(20))
print(s.rjust(20, '*')) #右对齐
'''右对齐,用0填充'''
print(s.zfill(20))
print('-200'.zfill(20)) #返回值为 -0000000000000200
#字符串的分割
s = 'hello world python'
lst = s.split()
print(lst)
s1 = 'hello|world|python'
print(s1.split(sep = '|')) #sep 指定分隔符
print(s1.split(sep = '|', maxsplit = 1)) #指定最大分割次数
print(s1.rsplit(sep = '|', maxsplit = 1)) #rsplit 从右边开始分割
#判断字符串操作
#isidentifier 字符串是不是全部为合法标识符
s = 'hello.python'
print('1.', s.isidentifier())
print('2.', 'hello'.isidentifier())
print('3.', '张三_'.isidentifier())
#isspace() 判断是否全部都是空白字符组成
print('4.', '\t\n'.isspace())
#isalpha 是否全部是字母
print('5.', 'abscdef'.isalpha())
#isdecimal() 是否全部由十进制数字组成
print('6.', '2423415799'.isdecimal())
#isnumeric 是否全部都是数字
print('7.', '12345678五六七90贰'.isnumeric()) #其他语言的数字也是数字返回True
#isalnum() 是否全部由字母和数字
print('8.', '123abc'.isalnum())
#字符串的替换与合并
s = '123456789123'
print(s.replace('123', '321', 1)) #替换操作 第三个参数为最大的替换次数
lst = ['hello', 'world', 'python']
print('|'.join(lst)) #用字符串去连接列表元组。。。
print('*'.join('Python'))
#字符串的比较操作
print('app' < 'apple')
print('apple' > 'banana')
print(ord('a'), ord('b'))
print(ord('赵'))
print(chr(97), chr(98))
print(chr(36213))
''' == 和 is 的区别, == 比较的是value is 比较的是id是否相等'''
#字符串的切片操作
# 字符串为不可变类型 不具备增删改的操作,只能产生新的对象
# 无起始位置从0开始切, 无结束位置切到最后
s = 'habcde Pythonl'
s1 = s[ : 5]
s2 = s[6 : ]
s3 = '!'
newstr = s1 + s2 + s3
print(s1)
print(s2)
print(newstr)
print(s[1 : 1 : 2]) # 第三个参数为step 步长也就是说,位数不够则不切, 位数够才会切去第一个
print(s[ : : 2])
print(s[ : : -1]) #从最后一个字符串开始,到字符串的第一个元素
#格式化字符串
#% 占位符
name = '萧炎'
age = 20
print('我叫%s, 今年%d岁' % (name, age))
# {}
print('我叫{0},今年{1}岁'.format(name, age))
# f-string
print(f'我叫{name}, 今年{age}岁')
print('%010d' % 1)
print('%10.3f' %3.1415926) #与c类似
print('{0:.3}'.format(3.1415926)) #三位数
print('{0:.3f}'.format(3.1415926)) #三位小数
print('{0:10.3f}'.format(3.1415926))
#函数的定义与调用
def add(a, b):
print(a, b)
c = a + b
return c
res = add(1, 2)
print(res)
#函数调用的参数传递
res = add(b = 10, a = 20) # 关键字传参, 所以最后的时候a = 20, b = 10, 不去定义a, b则使用的是位置传参,与参数一一对应
print(res)
def fun(arg1, arg2):
arg1 = 100
arg2.append(10)
n1 = 10
n2 = [22, 33, 44]
print('n1', n1)
print('n2', n2)
fun(n1, n2)
print('n1', n1)
print('n2', n2)
'''函数调用过程中, 不可变对象的值不会在函数体内进行改变, 可变对象的值会改变'''
# 函数的返回值 函数返回多个值时, 结果为元组
def test(num):
odd = []
even = []
for i in num:
if i % 2:
odd.append(i)
else:
even.append(i)
return odd, even
L = [10, 20, 30, 11, 13, 15]
print(test(L))
def test1():
print('hello')
test1()
def test2():
return 'hello'
res = test2()
print(res)
def test3():
return 'hello', 'world'
print(test3())
#函数的默认参数
def test4(a, b = 20):
return a + b
print(test4(10))
print(test4(10, 10))
# 个数可变的位置参数
def fun(*a): #个数可变的位置参数只能有一个
print(a)
print(a[0])
fun(10)
fun(10, 20, 30)
fun(30, 20, 10)
#个数可变的关键字形参 只能有一个
def fun1(**x):
print(x)
fun1(a = 10, b = 20, c = 30)
fun1(a = 10)
#如果机用位置参数又使用关键字参数, 位置形参放在关键字形参之前
#def fun2(*a, **x)
#列表传参
def fun2(a = 100, b = 200, c = 300):
print('a = ', a)
print('b = ', b)
print('c = ', c)
list = [10, 20, 30]
fun2(*list)
#字典传参
dic = {'a' : '111', 'b' : '222', 'c' : '333'}
fun2(**dic)
def fun3(a, b, *, c, d):
print('a = ', a)
print('b = ', b)
print('c = ', c)
print('d = ', d)
fun3(20, 10, d = 10, c = 20) #*号之后的只能使用关键字传参
#形参顺序问题
def fun5(a, b, *, c, d, **arg):
pass
def fun6(*aeg, **arg):
pass
def fun(a, b = 10, *arg, **aeg):
pass
#变量的作用域
def test(a, b):
c = a + b
print(c)
test(10, 20)
a = 10
def test1():
print(a)
test1()#a 为全局变量
def test2():
global b
b = 20
test2()
print(b) #这个地方b在函数中用 global声明, 为全局函数, 但是必须调用一遍该函数, 否则报错
#递归函数
def fac(n):
if n == 1:
return 1
else:
return n * fac(n - 1)
print(fac(7))
收藏了收藏了