首页
网站导航
关于
Search
1
解决Typecho Joe主题访问fastly.jsdelivr.net速度慢的方案 | 快速优化技巧
2,188 阅读
2
解决WSL2内存不释放问题的最佳指南
1,399 阅读
3
如何在 Typecho Joe 主题的文章中增加目录
1,170 阅读
4
GO语言环境的搭建教程 - 完全指南
1,003 阅读
5
如何解决Win11电脑桌面上方显示横线问题 | 窗口11教程
1,003 阅读
默认分类
编程语言
GO语言
PHP
Node
javascript
html
rust
java
Css
Python
资源分享
chrome插件
阅读思考
运维架构
redis
Nginx
linux
memcached
mongodb
mysql
windows
docker
k8s
Mq
apache
CI
Git
swoole
elk
系统设计
thinkPhp
beego
登录
Search
标签搜索
重要
go基础
git 命令
go包
phpstorm
sublime
thinkphp6
mysql问题
软件分享
redis命令
php基础
thinkphp3.2
php第三扩展包
小蚯蚓博客
累计撰写
333
篇文章
累计收到
48
条评论
首页
栏目
默认分类
编程语言
GO语言
PHP
Node
javascript
html
rust
java
Css
Python
资源分享
chrome插件
阅读思考
运维架构
redis
Nginx
linux
memcached
mongodb
mysql
windows
docker
k8s
Mq
apache
CI
Git
swoole
elk
系统设计
thinkPhp
beego
页面
网站导航
关于
搜索到
7
篇与
的结果
2023-02-05
Python的常用函数 - 掌握Python编程的核心
isinstance isinstance 用于判断对象是否属于某个类或者它的子类 name = "张三" print(isinstance(name, str)) str str() 函数能将 int 类型、float 类型的数据转换成字符串类型。 age = 12 print(type(str(age))) # <class 'str'>
2023年02月05日
252 阅读
0 评论
0 点赞
2023-02-05
Python 中的 JSON 解析指南
解析 通过 json.loads 来解析 import json aa = json.loads('{"name":"abc"}') print(aa) # {'name': 'abc'}
2023年02月05日
214 阅读
0 评论
0 点赞
2023-02-05
Python 运算符解析 | Python 编程语言
算数运算符 算术运算符也即数学运算符,用来对数字进行数学运算,比如加减乘除。下表列出了 Python 支持所有基本算术运算符。 运算符 说明 实例 结果 + 加 12.45 + 15 27.45 - 减 4.56 - 0.26 4.3 * 乘 5 * 3.6 18.0 / 除法(和数学中的规则一样) 7 / 2 3.5 // 整除(只保留商的整数部分) 7 // 2 3 % 取余,即返回除法的余数 7 % 2 1 ** 幂运算/次方运算,即返回 x 的 y 次方 2 ** 4 16,即 24 接下来将对表 1 中各个算术运算符的用法逐一讲解。 + 加法运算符 加法运算符很简单,和数学中的规则一样,请看下面的代码: m = 10 n = 97 sum1 = m + n x = 7.2 y = 15.3 sum2 = x + y # sum1=107, sum2=22.50 print("sum1=%d, sum2=%.2f" % (sum1, sum2) ) 拼接字符串 当 + 用于数字时表示加法,但是当 + 用于字符串时,它还有拼接字符串(将两个字符串连接为一个)的作用,请看代码: name = "C语言中文网" url = "http://c.biancheng.net/" age = 8 info = name + "的网址是" + url + ",它已经" + str(age) + "岁了。" # C语言中文网的网址是http://c.biancheng.net/,它已经8岁了。 print(info) - 减法运算符 减法运算也和数学中的规则相同,请看代码: n = 45 m = -n x = -83.5 y = -x # -45 , 83.5 print(m, ",", y) 求负数 - 除了可以用作减法运算之外,还可以用作求负运算(正数变负数,负数变正数),请看下面的代码: n = 45 n_neg = -n f = -83.5 f_neg = -f # -45 , 83.5 print(n_neg, ",", f_neg) 注意,单独使用 + 是无效的,不会改变数字的值,例如: n = 45 m = +n x = -83.5 y = +x # 45 , -83.5 print(m, ",", y) *乘法运算符 乘法运算也和数学中的规则相同,请看代码: n = 4 * 25 f = 34.5 * 2 # 100 , 69.0 print(n, ",", f) 重复字符串 * 除了可以用作乘法运算,还可以用来重复字符串,也即将 n 个同样的字符串连接起来,请看代码: # Hello hello hello hello str1 = "hello "print(str1 * 4) / 和 // 除法运算符 Python 支持 / 和 // 两个除法运算符,但它们之间是有区别的: / 表示普通除法,使用它计算出来的结果和数学中的计算结果相同。 // 表示整除,只保留结果的整数部分,舍弃小数部分;注意是直接丢掉小数部分,而不是四舍五入。 请看下面的例子: print("23/5 =", 23/5) # 4.6 print("23//5 =", 23//5) # 4 print("23.0//5 =", 23.0//5) # 4.0 从运行结果可以发现: / 的计算结果总是小数,不管是否能除尽,也不管参与运算的是整数还是小数。 当有小数参与运算时,// 结果才是小数,否则就是整数。 需要注意的是,除数始终不能为 0,除以 0 是没有意义的,这将导致 ZeroDivisionError 错误。在某些编程语言中,除以 0 的结果是无穷大(包括正无穷大和负无穷大)。 Python 2. X 中的除法 Python 2. X 只提供了一种除法运算,就是 /,它的行为和大部分编程语言中 / 的行为是一样的: 当 / 两边都是整数时,结果始终是整数;如果不能除尽,就直接舍弃小数部分。 当 / 两边有一个是小数时,结果始终是小数;如果恰好除尽,小数部分就是 0。 请看下面的代码: print 18/6 # 3 print 47/7 # 6 print 18.0/6 # 3.0 print 47.0/7 # 6.71428571429 print 29.5/4.2 # 7.02380952381 你可以将 Python 2. X 中的 / 看作 Python 3. X 中 / 和 // 的结合体,因为 Python 2. X 中 / 的行为有点奇怪,所以 Python 3. X 增加了 // 运算符,用以规范除法运算的行为。 % 求余运算符 Python % 运算符用来求得两个数相除的余数,包括整数和小数。Python 使用第一个数字除以第二个数字,得到一个整数的商,剩下的值就是余数。对于小数,求余的结果一般也是小数。 注意,求余运算的本质是除法运算,所以第二个数字也不能是 0,否则会导致 ZeroDivisionError 错误。 Python % 使用示例: print("-----整数求余-----") print(15%6) # 3 print(-15%6) # 3 print(15%-6) # -3 print(-15%-6) # -3 print("-----小数求余-----") print("7.7%2.2 =", 7.7%2.2) # 1.0999999999999996 print("-7.7%2.2 =", -7.7%2.2) #1.1000000000000005 print("7.7%-2.2 =", 7.7%-2.2)#-1.1000000000000005 print("-7.7%-2.2 =", -7.7%-2.2)#-1.0999999999999996 print("---整数和小数运算---") print("23.5%6 =", 23.5%6)#5.5 print("23%6.5 =", 23%6.5)#3.5 print("23.5%-6 =", 23.5%-6)#-0.5 print("-23%6.5 =", -23%6.5)#3.0 print("-23%-6.5 =", -23%-6.5)#-3.5 从运行结果可以发现两点: 只有当第二个数字是负数时,求余的结果才是负数。换句话说,求余结果的正负和第一个数字没有关系,只由第二个数字决定。 % 两边的数字都是整数时,求余的结果也是整数;但是只要有一个数字是小数,求余的结果就是小数。 ** 次方(乘方)运算符 Python ** 运算符用来求一个 x 的 y 次方,也即次方(乘方)运算符。由于开方是次方的逆运算,所以也可以使用 ** 运算符间接地实现开方运算。Python ** 运算符示例: print('----次方运算----') print('3**4 =', 3**4)#81 print('2**5 =', 2**5)#32 print('----开方运算----') print('81**(1/4) =', 81**(1/4))#3.0 print('32**(1/5) =', 32**(1/5))#2.0 三目运算符 Python 是一种极简主义的编程语言,它没有引入 ? : 这个新的运算符,而是使用已有的 if else 关键字来实现相同的功能。使用 if else 实现三目运算符(条件运算符)的格式如下: exp1 if contion else exp2 Condition 是判断条件,exp1 和 exp2 是两个表达式。如果 condition 成立(结果为真),就执行 exp1,并把 exp1 的结果作为整个表达式的结果;如果 condition 不成立(结果为假),就执行 exp2,并把 exp2 的结果作为整个表达式的结果。 三目运算符的嵌套 Python 三目运算符支持嵌套,如此可以构成更加复杂的表达式。在嵌套时需要注意 if 和 else 的配对,例如: a if a>b else c if c>d else d # 等效 a if a>b else ( c if c>d else d ) 赋值运算符 赋值运算符用来把右侧的值传递给左侧的变量(或者常量);可以直接将右侧的值交给左侧的变量,也可以进行某些运算后再交给左侧的变量,比如加减乘除、函数调用、逻辑运算等。 Python 中最基本的赋值运算符是等号=;结合其它运算符,=还能扩展出更强大的赋值运算符。 基本赋值运算符 = 是 Python 中最常见、最基本的赋值运算符,用来将一个表达式的值赋给另一个变量,请看下面的例子: #将字面量(直接量)赋值给变量 n1 = 100 f1 = 47.5 s1 = "http://c.biancheng.net/python/" #将一个变量的值赋给另一个变量 n2 = n1 f2 = f1 #将某些运算的值赋给变量 sum1 = 25 + 46 sum2 = n1 % 6 s2 = str(1234) #将数字转换成字符串 s3 = str(100) + "abc" 连续赋值 Python 中的赋值表达式也是有值的,它的值就是被赋的那个值,或者说是左侧变量的值;如果将赋值表达式的值再赋值给另外一个变量,这就构成了连续赋值。请看下面的例子: a = b = c = 100 = 具有右结合性,我们从右到左分析这个表达式: c = 100 表示将 100 赋值给 c,所以 c 的值是 100;同时,c = 100 这个子表达式的值也是 100。 b = c = 100 表示将 c = 100 的值赋给 b,因此 b 的值也是 100。 以此类推,a 的值也是 100。 最终结果就是,a、b、c 三个变量的值都是 100。 = 和 == = 和 == 是两个不同的运算符,= 用来赋值,而 == 用来判断两边的值是否相等,千万不要混淆。 扩展后的赋值运算符 = 还可与其他运算符(包括算术运算符、位运算符和逻辑运算符)相结合,扩展成为功能更加强大的赋值运算符,如表 1 所示。扩展后的赋值运算符将使得赋值表达式的书写更加优雅和方便。 运算符 说明 用法举例 等价形式 = 最基本的赋值运算 x = y x = y += 加赋值 x += y x = x + y -= 减赋值 x -= y x = x - y *= 乘赋值 x *= y x = x * y /= 除赋值 x /= y x = x / y %= 取余数赋值 x %= y x = x % y **= 幂赋值 x **= y x = x ** y //= 取整数赋值 x //= y x = x // y &= 按位与赋值 x &= y x = x & y |= 按位或赋值 x |= y x = x | y ^= 按位异或赋值 x ^= y x = x ^ y <<= 左移赋值 x <<= y x = x << y,这里的 y 指的是左移的位数 >>= 右移赋值 x >>= y x = x >> y,这里的 y 指的是右移的位数 这里举个简单的例子: n1 = 100 f1 = 25.5 n1 -= 80 #等价于 n1=n1-80 f1 *= n1 - 10 #等价于 f1=f1*( n1 - 10 ) print("n1=%d" % n1) # 20 print("f1=%.2f" % f1) # 255.00 通常情况下,只要能使用扩展后的赋值运算符,都推荐使用这种赋值运算符。 但是请注意,这种赋值运算符只能针对已经存在的变量赋值,因为赋值过程中需要变量本身参与运算,如果变量没有提前定义,它的值就是未知的,无法参与运算。例如,下面的写法就是错误的: n += 10 该表达式等价于 n = n + 10,n 没有提前定义,所以它不能参与加法运算。 位运算符 Python 位运算按照数据在内存中的二进制位(Bit)进行操作,它一般用于底层开发(算法设计、驱动、图像处理、单片机等),在应用层开发(Web 开发、Linux 运维等)中并不常见。想加快学习进度,或者不关注底层开发的读者可以先跳过本节,以后需要的话再来学习。这里了略过 比较运算符 比较运算符,也称关系运算符,用于对常量、变量或表达式的结果进行大小比较。如果这种比较是成立的,则返回 True(真),反之则返回 False(假)。 Python 支持的比较运算符如下 比较运算符 说明 > 大于,如果>前面的值大于后面的值,则返回 True,否则返回 False。 < 小于,如果<前面的值小于后面的值,则返回 True,否则返回 False。 == 等于,如果==两边的值相等,则返回 True,否则返回 False。 >= 大于等于(等价于数学中的 ≥),如果>=前面的值大于或者等于后面的值,则返回 True,否则返回 False。 <= 小于等于(等价于数学中的 ≤),如果<=前面的值小于或者等于后面的值,则返回 True,否则返回 False。 != 不等于(等价于数学中的 ≠),如果!=两边的值不相等,则返回 True,否则返回 False。 is 判断两个变量所引用的对象是否相同,如果相同则返回 True,否则返回 False。 is not 判断两个变量所引用的对象是否不相同,如果不相同则返回 True,否则返回 False。 == 和 is 的区别 初学 Python,大家可能对 is 比较陌生,很多人会误将它和 == 的功能混为一谈,但其实 is 与 == 有本质上的区别,完全不是一码事儿。 == 用来比较两个变量的值是否相等,而 is 则用来比对两个变量引用的是否是同一个对象,例如: import time #引入time模块 t1 = time.gmtime() # gmtime()用来获取当前时间 t2 = time.gmtime() print(t1 == t2) #输出True print(t1 is t2) #输出False Time 模块的 gmtime () 方法用来获取当前的系统时间,精确到秒级,因为程序运行非常快,所以 t1 和 t1 得到的时间是一样的。== 用来判断 t1 和 t2 的值是否相等,所以返回 True。 虽然 t1 和 t2 的值相等,但它们是两个不同的对象(每次调用 gmtime () 都返回不同的对象),所以 t1 is t2 返回 False。这就好像两个双胞胎姐妹,虽然她们的外貌是一样的,但它们是两个人。 那么,如何判断两个对象是否相同呢?答案是判断两个对象的内存地址。如果内存地址相同,说明两个对象使用的是同一块内存,当然就是同一个对象了;这就像两个名字使用了同一个身体,当然就是同一个人了。 逻辑运算符 高中数学中我们就学过逻辑运算,例如 p 为真命题,q 为假命题,那么“p 且 q”为假,“p 或 q”为真,“非 q”为真。Python 也有类似的逻辑运算,请看下表: 逻辑运算符 含义 基本格式 说明 and 逻辑与运算,等价于数学中的“且” a and b 当 a 和 b 两个表达式都为真时,a and b 的结果才为真,否则为假。 or 逻辑或运算,等价于数学中的“或” a or b 当 a 和 b 两个表达式都为假时,a or b 的结果才是假,否则为真。 not 逻辑非运算,等价于数学中的“非” not a 如果 a 为真,那么 not a 的结果为假;如果 a 为假,那么 not a 的结果为真。相当于对 a 取反。 逻辑运算符一般和关系运算符结合使用,例如: 14>6 and 45.6 > 90 Python 逻辑运算符可以用来操作任何类型的表达式,不管表达式是不是 bool 类型;同时,逻辑运算的结果也不一定是 bool 类型,它也可以是任意类型。请看下面的例子: print(100 and 200) # 200 print(45 and 0) # 0 print("" or "http://c.biancheng.net/python/") # http://c.biancheng.net/python/ print(18.5 or "http://c.biancheng.net/python/") # 18.5 上例中的执行结果可以用短路原理来解释。 in 和 not in in 与 not in 操作符, 可以判定一个值是否在列表中。 books = ['梦的化石', '冬泳', '鱼翅与花椒'] new_book = '莫斯科绅士' if '莫斯科绅士' not in books: print(new_book + '不在书单中,现在添加……') books.append(new_book) if '莫斯科绅士' in books: print(new_book + '已经在书单中。') print('books = ' + str(books)) 字符串也可以利用 in 与 not in 操作符来判断某个字符是否存在: is_exist = '绅士' in '莫斯科绅士' print(is_exist) is_exist = '科' in '莫斯科绅士' print(is_exist) is_not_exist = '冬泳' not in '莫斯科绅士' print(is_not_exist) 字典的 key 也可以判断 data = { 'zh-cn': "中文简体", 'zh-tw': "中文繁体", } language = data['zh-cn'] if 'zh-cn' in data and data['zh-cn'] else '暂无语言' print(language) # 中文简体 运算符的优先级 Python 支持几十种运算符,被划分成将近二十个优先级,有的运算符优先级不同,有的运算符优先级相同,请看下表。 运算符说明 Python 运算符 优先级 结合性 小括号 ( ) 19 无 索引运算符 x[i] 或 x[i1: i2 [:i3]] 18 左 属性访问 x.attribute 17 左 乘方 ** 16 右 按位取反 ~ 15 右 符号运算符 +(正号)、-(负号) 14 右 乘除 *、/、//、% 13 左 加减 +、- 12 左 位移 >>、<< 11 左 按位与 & 10 右 按位异或 ^ 9 左 按位或 | 8 左 比较运算符 ==、!=、>、>=、<、<= 7 左 is 运算符 is、is not 6 左 in 运算符 in、not in 5 左 逻辑非 not 4 右 逻辑与 and 3 左 逻辑或 or 2 左 逗号运算符 exp1, exp2 1 左 结果表中的运算符优先级,我们尝试分析下面表达式的结果: 4+4<<2 + 的优先级是 12,<< 的优先级是 11,+ 的优先级高于 <<,所以先执行 4+4,得到结果 8,再执行 8<<2,得到结果 32,这也是整个表达式的最终结果。 当然,我们也可以使用 ( ) 改变程序的执行顺序,比如: 4+(4<<2) 则先执行 4<<2,得到结果 16,再执行 4+16,得到结果20。 运算符的结合性 谓结合性,就是当一个表达式中出现多个优先级相同的运算符时,先执行哪个运算符:先执行左边的叫左结合性,先执行右边的叫右结合性。 例如对于表达式对于100 / 25 * 16,/和*的优先级相同,应该先执行哪一个呢?这个时候就不能只依赖运算符优先级决定了,还要参考运算符的结合性。/和*都具有左结合性,因此先执行左边的除法,再执行右边的乘法,最终结果是 64。 Python 中大部分运算符都具有左结合性,也就是从左到右执行;只有 ** 乘方运算符、单目运算符(例如 not 逻辑非运算符)、赋值运算符和三目运算符例外,它们具有右结合性,也就是从右向左执行。表 1 中列出了所有 Python 运算符的结合性。
2023年02月05日
177 阅读
0 评论
0 点赞
2023-02-02
Python编程规范:提高您的编程效率与质量
概述 这些规范如果不遵守的话,可能程序也不会报错,不过 idea 会有提示 规范 类的块和块之间推荐要2个空行,不过类的方法之间推荐只有一个空行 例如下例中,BaseQueryBatchPersonMailSchema 类和 QueryBatchPersonMailSchema 类,中间空了两行。 class BaseQueryBatchPersonMailSchema(Schema): """ 查询个人邮件 """ logical_region_id = permission.Logical(required=True) server_id = permission.Server(required=True) mail_batch_id = fields.String() class QueryBatchPersonMailSchema(BaseQueryBatchPersonMailSchema): """ 查询批次个人邮件 """ page_no = fields.Integer(required=True) page_size = fields.Integer(required=True) 代码中,最后一个要有一个空行 例如下例中,代码最后有一个空行 class QueryBatchPersonMailSchema(BaseQueryBatchPersonMailSchema): """ 查询批次个人邮件 """ page_no = fields.Integer(required=True) page_size = fields.Integer(required=True) 这里需要有个空行 参数缩进要对齐 例如下例中,mail_batch 参数和上一行的 logical_region_id 参数对齐了。 return self.service.query_person_mail_batch(logical_region_id, server_id, page_no, page_size, mail_batch=mail_batch)要和上一行对齐 在代码末尾注释,注释和代码中间要有两个空格 例如下例中,params) 和 # wqy.. 中间有两个空格 _, err = self.game_request(30411, logical_region_id, server_id, params) # wqytodo 需要确认接口号
2023年02月02日
184 阅读
0 评论
0 点赞
2023-02-02
Python3.7 安装教程和指南
下载 打开 python 官网的下载页面: https://www.python.org/downloads/windows/ 截止目前,Python 有两个版本,一个是 2.X 版,一个是 3.X 版,这两个版本是不兼容的。不过现在由于 python 的 3.X 版越来越普及,这里的安装教程以 python3.7 为例。 安装 直接双击下载的 exe 文件一直下一步安装即可,需要注意的是,最好将勾选加入环境变量,到此 python 的安装就已经结束了。
2023年02月02日
220 阅读
0 评论
0 点赞
2023-01-05
Python类和对象教程- Python Class学习指南
定义 简单的声明如下所示: class Person: def __init__(self, name, age): self.name = name self.age = age def get_name(self): print(self.name) p = Person("张三") p.get_name() print(p.name,p.age) 首字母大写的代表是类,调用的时候,表示实例化,区分函数调用,不过这只是规范而已。 变量 类变量 在定义类时,定义在类内部,所有方法外部的变量叫做类变量。例如下例中的 dogColor 类变量 # coding=utf-8 class Dog(): dogColor = "yellow" def __init__(self, name, age): self.name = name self.age = age def seeColor(self): print(self.dogColor) 或者通过 类名.类变量 = 值 的方式来动态创建 # coding=utf-8 class Dog(): def __init__(self, name, age): self.name = name self.age = age def seeSex(self): print(self.dogColor) Dog.Sex = "boy" dog1 = Dog("阿黄", 12) dog1.seeSex() 类变量修改只能通过 类名.类变量 = 值 来修改,不能通过 实例变量.类变量 = 值 来修改。并且此修改是全局性的,一旦修改,所有的实例调用都会改变。 实例变量 定义在类的所有方法内部定义,以 self.变量 出现的变量叫做实例变量。例如下例中的 name 和 age # coding=utf-8 class Dog(): def __init__(self, name, age): self.name = name self.age = age dog1 = Dog("阿黄", 12) dog1.seeSex() 实例变量只能通过实例对象调用,不能通过类调用;实例变量属于实例对象私有的。 局部变量 在类方法内使用的普通变量,例如变量 legAmout # coding=utf-8 class Dog(): def __init__(self, name, age): self.name = name self.age = age legAmout = 4 dog1 = Dog("阿黄", 12) dog1.seeSex() 全局变量 在类的方法里,变量前面加上 global,表示可以修改全局变量,如果不加 global 也可以访问,但是无法修改 # coding=utf-8 distance = 100 class Dog(): def __init__(self): global distance distance = 200 class Dog1(): def __init__(self): print(distance) # 被修改成了200 dog1 = Dog() dog2 = Dog1() # 输出200 构造函数 上例子中的 __init__ 方法是构造函数 class Person: def __init__(self, name, age): self.name = name self.age = age 构造函数在实例化的时候会自动调用。有三个参数,形参 self 必不可少,而且必须位于其他形参的前面,实例化的时候将自动传入实参 self。每个与实例相关联的方法调用都自动传递实参 self,它是一个指向实例本身的引用。 方法 实例方法 一般我们在类当中定义的方法都是实例方法,定义中必须使用 self 关键字作为第一个参数,要使用实例方法,必须先把我们的类实例化才能使用。比如下面的个 Dog 类中的 name 方法。 # coding=utf-8 class Dog(): def __init__(self, name, age): self.name = name self.age = age # 实例方法必须带有self参数 def dogName(self): print("我是一只狗,名叫{}".format(self.name)) dog1 = Dog("阿黄", 12) # 只能通过实例对象才能调用实例方法 dog1.dogName() 实例方法可以访问实例变量、类变量,使用时必须通过实例名来调用。 类方法 在定义函数的时候在前面加上 @classmethod 那么接下来定义的这个函数就被称为类方法,如下所示 # coding=utf-8 class Dog(): dog_dict = { "大狗":3, "二狗":4, "三狗":5 } def __init__(self, name, age): self.name = name self.age = age @classmethod def dogAge(cls): print(cls.dog_dict) # 类名来调用 Dog.dogAge() 类方法不会因为具体的哪个实例而改变,因此在定义时必须使用 cls (应该是 class 的简写,表示类变量) 作为第一个参数。 类方法可以使用类名或者实例来调用 dog1 = Dog("阿黄", 12) dog1.dogAge() # 或 Dog.dogAge() 类方法是可以访问类变量,当然也可以访问实例变量 (不过需要传入参数 self,并且在使用时需要把实例名传入函数中)。 # coding=utf-8 class Dog(): dog_dict = { "大狗":3, "二狗":4, "三狗":5 } def __init__(self, name, age): self.name = name self.age = age @classmethod def dogAge(cls, instance): print(cls.dog_dict,instance.name) # 类名来调用 dog1 = Dog("阿黄", 12) Dog.dogAge(dog1) # 传入实例 静态方法 定义函数的时候在前面加上 @staticmethod 那么接下来定义的这个函数就被称为静态方法。静态方法不要求你强制传入任何参数(实例方法必须传入 slef,类方法必须传入 cls),因此这个函数对类变量和实例变量都是一无所知,你需要自己传入参数才能使用。 调用的时候,可以使用 实例名. 方法名 调用,或者 类名.方法名 调用。看例子 # coding=utf-8 class Dog(): dog_dict = { "大狗":3, "二狗":4, "三狗":5 } def __init__(self, name, age): self.name = name self.age = age @staticmethod def say(): print("旺旺!") dog1 = Dog("阿黄", 12) dog1.say() Dog.say() 继承 简单的使用如下,继承 Person 类 class BlackPerson(Person): def __init__(self, name, age): super().__init__(name, age) self.skin = "黑色皮肤" # 子类特有的属性 def get_skin(self): print(self.skin) p = BlackPerson("Jack张", 18) p.get_addr() p.get_skin() Super () 是一个特殊函数,让你能够调用父类的方法。
2023年01月05日
376 阅读
0 评论
0 点赞
2022-12-25
Python基础教程 - 从入门到精通
基础知识 安装完成后可以使用 python 命令,终端输入 python 后,可以输入代码,ctrl+z 然后回车可以退出,或 exit() 文件名和文件夹名称最好使用小写字母,使用下划线代替空格,这是规范 文件末尾为 .py 变量 变量的基本使用如下,没有关键字,也没有 php 的 $ : message = "hello world" print(message) 关于变量的命名规则规范,和其他语言一样,略过。 可以一下子个多个变量赋值,左右数量要对上: x,y = 1,2 print(x) # 1 print(y) # 2 Python 中没有常量类型,会使用全大写来指出应将某个变量视为常量,其值应始终不变 MAX_CONNECTION_AMOUNT = 100 print(MAX_CONNECTION_AMOUNT) 字符串 用引号括起的都是字符串,其中的引号可以是单引号,也可以是双引号。好处是:这种灵活性让你能够在字符串中包含引号和撇号。 message1 = 'hello world "~" ' message2 = "hello world '~' " print(message1,message2) 可以调用字符串变量的方法,对字符串进行操作 message1 = 'hello world' print(message1.title()) # 首字母大写 print(message1.upper()) print(message1.lower()) 字符串中使用变量,可在前引号前加上字母 f,是字母 format 的缩写,让 python 来格式化替换,然后再在花括号里输入变量名称。这种字符串叫做 f 字符串 first_name = "张" last_name = "三" full_name = f"{first_name}{last_name}" print(full_name) # 3.6 版本以前需要这样替换 # 将按顺序将这些花括号替换为圆括号内列出的变量的值 first_name = "张" last_name = "三" full_name = "{}{}".format(first_name,last_name) print(full_name) # 也可以指定变量名称 err = "{item_type}_{item_id}".format(item_type=item_type, item_id=item_id) # 可以使用格式化语法 str = '"虚拟金额"不在服务端指定金额内:%d' % (item["fake_amount"]) str = '"虚拟金额"不在服务端指定金额内:%d' % fake_amount 使用制表符或换行符来添加空白,单引号和双引号没有区别,不像 php languages = '编程语言有:\n\t1.PHP\n\t2.Goland' print(languages) 删除空白字符串,制表符、空格啥的都算空白字符。 languages = ' 最喜欢的编程语言是:PHP! ' print(languages.lstrip()) # 删除左边的空白字符 print(languages.rstrip()) # 删除右边的空白字符 数 简单的加减乘除, 求模,整数和浮点数都可以 # 整数运算 print(1+1) print(1-2) print(1*2) print(1/2) print(1%2) print(2 + 3*4) # 14 print((2 + 3) * 4) # 20 # 浮点数 print(0.1 + 0.1) 使用两个乘号表示乘方运算 print(2 ** 2) # 2的2次方 print(3 ** 2) # 3的2次方 Python 将所有带小数点的数称为浮点数,将任意两个数相除时,结果总是浮点数,即便这两个数都是整数且能整除 print(4/2) # 2.0 在其他任何运算中,如果一个操作数是整数,另一个操作数是浮点数,结果也总是浮点数: print(1.0 + 2) # 3.0 书写很大的数时,可使用下划线将其中的数字分组,使其更清晰易读 money = 1_000 # 1千 print(money) # 1000 注释 使用 # 注释 # 输出hello print("hellow") 列表介绍 Python 使用两个方扩号表示列表,类似 php 的数组 languages = ["PHP","Goland","Python"] print(languages) 使用 len () 方法来获取长度 languages = ["PHP","Goland","Python","Java"] print(len(languages)) # 4``` 访问 访问列表元素,从 0 开始 languages = ["PHP","Goland","Python"] print(languages[0]) 访问最后一个列表元素提供了一种特殊语法。通过将索引指定为 -1,可让 Python 返回最后一个列表元素 languages = ["PHP","Goland","Python"] print(languages[-1]) # python print(languages[-2]) # goland 可以像使用其他变量一样使用列表中的各个值 languages = ["PHP","Goland","Python"] print(languages[-1].upper()) # python print(f"最后一个语言是{languages[-1]}") # python 访问不存在的 index,会报错 languages = ["PHP","Goland","Python","Java"] print(languages[5]) # 4 增删改 修改列表中的元素,这个和 php 的数组修改方式是一样的 languages = ["PHP","Goland","Python"] languages[0] = "php" print(languages) # ['php', 'Goland', 'Python'] 使用 append 方法向末尾添加 languages = ["PHP","Goland","Python"] languages.append("Java") print(languages) # ['PHP', 'Goland', 'Python', 'Java'] 还可以在中间插入 languages = ["PHP","Goland","Python"] languages.insert(1,"Java") print(languages) # ['PHP', 'Java', 'Goland', 'Python'] 使用 del 语句删除元素 languages = ["PHP","Goland","Python","Java"] del languages[3] print(languages) # ['PHP', 'Goland', 'Python'] 也可以使用 pop 来弹出,需要注意的是,可以指定弹出哪个位置的元素 languages = ["PHP","Goland","Python","Java"] print(languages.pop()) # java print(languages.pop(1)) # Goland print(languages) # ['PHP', 'Python'] 根据值来删除,方法 remove () 只删除第一个指定的值。如果要删除的值可能在列表中出现多次,就需要使用循环来确保将每个值都删除。 languages = ["PHP","Goland","Python","Java"] languages.remove('Java') print(languages) # ['PHP', 'Goland', 'Python'] 排序 方法 sort (),永久性地修改列表元素的排列顺序 languages = ["PHP","Goland","Python","Java"] languages.sort() print(languages) # 正序 ['Goland', 'Java', 'PHP', 'Python'] languages.sort(reverse=True) print(languages) # 反序 ['Python', 'PHP', 'Java', 'Goland'] 使用 sorted () 方法,临时排序并且返回 languages = ["PHP","Goland","Python","Java"] print(sorted(languages)) # 正序 ['Goland', 'Java', 'PHP', 'Python']print(languages) # ['PHP', 'Goland', 'Python', 'Java'] 列表元素顺序反转,不是降序排序 languages = ["PHP","Goland","Python","Java"] languages.reverse() print(languages) # ['Java', 'Python', 'Goland', 'PHP'] 遍历 使用 for…in…: 来遍历,缩进里面的代表是循环体里的 languages = ["PHP","Goland","Python","Java"] for language in languages: print(language) # 缩进,在循环体里 print("finish") # 不在循环体里 对不能缩进的代码进行缩进,会报错 languages = ["PHP","Goland","Python","Java"] print(languages) # 这个不能缩进 便利的时候,带有 index for index, item in enumerate(activity_dict['active_cfg_list'], start=1): print(index) 可以快速的转为字典 order_dict = {order['order_id']: order for order in data['order_info_list']} 数值列表 使用 range 创建数值列表,类似 php 里的迭代器,可以用于遍历 for ele in range(1,5): print(ele) 对数字列表执行简单的统计计算 numbers = [1,2,3,4,5,6] print(min(numbers)) print(max(numbers)) print(sum(numbers)) 列表解析,快速生成列表 numbers = [value**2 for value in range(1,3)] print(numbers) # [1, 4] 切片 还可以处理列表的部分元素,Python 称之为切片。左包含,右不包含 languages = ["PHP","Goland","Python","Java"] print(languages[0:2]) # ['PHP', 'Goland'] print(languages[:2]) # ['PHP', 'Goland'] print(languages[2:]) # ['Python', 'Java'] print(languages[:]) # ['PHP', 'Goland', 'Python', 'Java'] print(languages) # ['PHP', 'Goland', 'Python', 'Java'] 切片也可以遍历 languages = ["PHP","Goland","Python","Java"] for ele in languages[:2]: print(ele) 如果要复制一份独立的列表,可以进行切片后复制,直接复制是引用 languages = ["PHP","Goland","Python","Java"] myL = languages[:] languages.pop() print(myL) # ["PHP","Goland","Python","Java"] 拼接字符串 用字符连接 award_name_str = ",".join(award_name_list) 元组 Python 将不能修改的值称为不可变的,而不可变的列表被称为 元组。不可修改!! languages = ("PHP","Goland","Python","Java") print(languages[1]) print(languages) # ('PHP', 'Goland', 'Python', 'Java') 可以被遍历。 格式 要提出 Python 语言修改建议,需要编写 Python 改进提案(Python Enhancement Proposal,PEP)。PEP 8 是最古老的 PEP 之一,向 Python 程序员提供了代码格式设置指南。 缩进:PEP 8 建议每级缩进都使用四个空格。而不是 tab 缩进。 PEP 8 还建议注释的行长不应超过 72 字符,因为有些工具为大型项目自动生成文档时,会在每行注释开头添加格式化字符 要将程序的不同部分分开,可使用空行 函数给形参指定默认值的时候,= 左右不能有空格,好像有空格也不会报错就是了 流程 条件测试 相等比较 ==,区分大小写,如果不想区分的话,可以转为大写后再比较,注意,字符串的 1 和数值的 1 是不相等的 不相等比较 !=,都一样略过 数值比较,>,>=,<,<=,这个都一样,略过 是否在列表中,使用关键字 in。 languages = ("PHP","Goland","Python","Java") if "PHP" in languages: print("zai") 是否不在列表中,使用关键字 in。 languages = ("PHP","Goland","Python","Java") if "js" not in languages: print("不在") 布尔表达式,字符串和布尔值比较的话,不管是 true 还是 false,都不会进去,数值类型可以比较 if "1.0" == True: print("不能比较") 多条件检查可以用:and、or If 每条 if 语句的核心都是一个值为 True 或 False 的表达式,这种表达式称为条件测试。也要缩进。并且 elif 和 else 是可以省略的 # if name = '张三' if name == "张三": print("是张三") # if else name = '张三' if name == "张三": print("是张三") else: print("不是张三") # if elif else name = '李四' if name == "张三": print("是张三") elif name == "李四": print("是李四") elif name == "王五": print("是王五") else: print("不是张三和李四和王五") 判断列表是否有值,不能和 true 和 false 比较,Python 将在列表至少包含一个元素时返回 True,并在列表为空时返回 False。 lan = [1] if lan: print("aa") 三目运算 server_id = int(params.get('server_id')) if params.get('server_id') else None not in list 判断 # not in list if item["fake_amount"] not in amount_list: is null 判断 # 相当于is_null(fake_amount) fake_amount is None 是否在数组或者集合中 # check_config_ids = [1,2] return config_id in set(check_config_ids) While 和其他语言一样,也可以使用 break 退出循环,使用 continue 跳过循环 current = 5 while current >= 0 : print(current) current -= 1 Python 好像没有 for 循环,只有 for in 循环。 字典 在 Python 中,字典是一系列键值对。每个键都与一个值相关联,你可使用键来访问相关联的值。与键相关联的值可以是数、字符串、列表乃至字典。 person = {'name': 'zhangSang', 'age': 30} print(person['name']) # key不存在也会报错 print(person.get("age",31)) # key不存在的话不会报错 添加和修改元素,删除元素 person = {'name': 'zhangSang', 'age': 30} person["name"] = "lisi" # 修改 person["sexy"] = "男" # 添加 del person['age'] # 删除 print(person) 可以遍历 # 遍历key-value person = {'name': 'zhangSang', 'age': 30} for key,value in person.items(): print(key,"=>",value) # 遍历key person = {'name': 'zhangSang', 'age': 30} for key in person.keys(): print(key) # 遍历值 person = {'name': 'zhangSang', 'age': 30} for value in person.values(): print(value) 需要注意的是,如果没 key,则是集合 personSet = { 'zhangSang', 30} for value in personSet: print(value) 可以在字典中存储字典,也可以在字典中存储列表,具体忽略。 输入 可以使用 input 来获取输入 message = input("请输入:") print(message) 因为输入的值,单做字符串,不可以和数值进行比较大小,否则会报错,所以要用 int 函数转换下 age = input("请输入年龄:") age = int(age) if age >= 12 : # 需要转换下,不然这会报错 print(age) 函数 简单的定义如下 def hello_world(): """文档字符串的注释,用于描述函数是干嘛的""" print("hellow world") hello_world() 加上参数 def hello_world(name): """文档字符串的注释,用于描述函数是干嘛的""" print("hellow world",name) hello_world("张三") 还有一些知识点: 传入参数可以位置实参,关键字实参。 形参的默认值和 php 都一样 返回也是和 php 一样。也可以返回多个值,接收变量也要对应 如果有要传入可变参数的话可以在形参前面加 *,例如 def hello_world(*param):,会创建一个空元组,类似 php 的 function hello_world(…param) 如果有要传入可变参数的话可以在形参前面加 **,可以传入键值对,存在字典中 def hello_world(**p): """文档字符串的注释,用于描述函数是干嘛的""" print(p) hello_world(a=1,b=2) # {'a': 1, 'b': 2} 参数后面的冒号是参数类型建议符,用来提供给程序员建议传入的实参类型,即使去掉也不会有任何影响。结尾的箭头 ->代表着 函数返回值建议符,用来提供函数返回值的数据类型。 class Solution: def search(self, nums: List[int], target: int) -> int: 模块 模块是扩展名为 .py 的文件,包含要导入到程序中的代码。通过将 函数和类 等存储在称为模块的独立文件中,再将模块导入到主程序中使用,可以使得代码更加清晰。模块名称就是文件名称。 然后直接导入后就可以使用,导入的时候,首先会从当前目录查找该模块的文件名称,然后将它复制过来 执行。导入方式有: # 导入整个模块内容 import hello # 导入模块中的函数、类、变量啥的 from hello import hello_world # 换行的话,要用\ from hello import hello_world1,hello_world2,\ hello_wordl3 from hello import * # 导入所有函数 # as 起别名 from hello import hello_world as hw import hello as hl 注意:导入就是将代码复制过来,导入的时候会执行模块文件里的代码。但是在一个模块来重复导入其他模块,只会执行一次。 包 目录中有 __init__.py 的就是包,所以可以说包就是目录,一个包里有很多个模块,模块就是一个文件。可以用 import 导入包。 类 简单的声明如下: class Person: def __init__(self, name, age): self.name = name self.age = age def get_name(self): print(self.name) p = Person("张三") p.get_name() print(p.name,p.age) 首字母大写的代表是类,调用的时候,表示实例化,区分函数调用,不过这只是规范而已。 构造函数 这个是构造函数,实例化的时候会自动调用。有三个参数,形参 self 必不可少,而且必须位于其他形参的前面,实例化的时候将自动传入实参 self。每个与实例相关联的方法调用都自动传递实参 self,它是一个指向实例本身的引用。 继承 简单的使用如下,继承 Person 类 class BlackPerson(Person): def __init__(self, name, age): super().__init__(name, age) self.skin = "黑色皮肤" # 子类特有的属性 def get_skin(self): print(self.skin) p = BlackPerson("Jack张", 18) p.get_addr() p.get_skin() super () 是一个特殊函数,让你能够调用父类的方法。 文件 读取 简单的语法如下所示,读取整个文件: with open("text.txt") as file_object: contents = file_object.read() print(contents.rstrip()) # 好像read的末尾多了一个空行 关键字 with 在不再需要访问文件后将其关闭,因为我们调用了 open (),但没有调用 close (),with 会自动在合适的时候关闭它。 还可以逐行读取 with open("text.txt") as file_object: for line in file_object: print(line) 还可以获取列表的行内容: with open("text.txt") as file_object: lines = file_object.readlines() print(lines) 还可以通过文件里解析 json 的格式内容 with open("text.txt") as file_object: contents = json.load(file_object) print(contents) 写入 简单的使用如下,可以选择模式,是追加还是覆盖 with open("text.txt",'w') as file_object: lines = file_object.write("haha") 还可以写入 json 数据 person = { "name":"张三", "age":20, } with open("text.txt",'w') as file_object: json.dump(person,file_object) 异常 简单是使用如下所示: try: answer = 5/1 except ZeroDivisionError: print("除数不能为0") else: print(answer) 如果没有异常就会执行 else 分支。 如果捕获异常后什么都不要做的话,可以使用 pass。pass 语句还充当了占位符,提醒你在程序的某个地方什么都没有做,并且以后也许要在这里做些什么。 try: answer = 5/0 except ZeroDivisionError: pass else: print(answer) 单元测试 简单使用 class TestHelloCase(unittest.TestCase): # 要继承这个类 def test_hello_world(self): tmp = hello.hello_world() # 这个返回值进行比较 self.assertEqual(tmp,"hello word") # 断言 if __name__ == '__main__': # 防止导入的时候被执行 unittest.main() 如果测试的是类,经常需要在方法里重复实例化,如果想要只实例化一次,可以使用 setup 方法存起来。 __name__ 是用来标识模块名字的一个系统变量。这里分两种情况: 第一种情况指的是当前运行的模块,那么当前模块 __name__ 的值就为 "main"; 第二种情况指的是该模块是使用 import 导入的模块,那么这个被导入模块的 __name__ 变量的值为该模块的文件名(去掉. py)
2022年12月25日
281 阅读
0 评论
0 点赞