python 基础2

最新推荐文章于 2024-09-24 11:20:26 发布

Maricat4

最新推荐文章于 2024-09-24 11:20:26 发布

阅读量145

点赞数 1

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/qq_32061629/article/details/106278618

版权

Python 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

python 基础2

一些python基础知识，以防忘记。

以下除了代码部分，大部分都来自与python官方文档，有许多删减，少许是与C++的比对。

逻辑值检测

任何对象都可以进行逻辑值的检测。一个对象在默认情况下均被视为真值，除非当该对象被调用时其所属类定义了 __bool__() 方法且返回 False 或是定义了 __len__() 方法且返回零。 1下面基本完整地列出了会被视为假值的内置对象:

被定义为假值的常量: None 和 False。
任何数值类型的零: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
空的序列和多项集: '', (), [], {}, set(), range(0)

示例

class A:
    #定义基本属性(没有下划线表示public类型)
    a = 0
    #定义私有属性(双下划线前缀表示private，单下划线表示protected)__b = 0#定义构造方
    def __init__(self,x,y):
        self.a = x
        self.__b = y
    
    def __bool__(self):
        return self.a>0

a = A(-1,5)
if a:
    print(1)
else:
    print(-1)
#输出-1，这里如若去__bool__方法，会输出1。__len__方法类似

布尔运算符

且或非对应于：and,or,not。C++:&&，||，！

Operation	Result
`x or y`	if x is false, then y, else x
`x and y`	if x is false, then x, else y
`not x`	if x is false, then `True`, else `False`

比较运算符

运算	含义
`<`	严格小于
`<=`	小于或等于
`>`	严格大于
`>=`	大于或等于
`==`	等于
`!=`	不等于
`is`	对象标识
`is not`	否定的对象标识

它们的优先级相同（比布尔运算的优先级高）。

==与is

除不同的数字类型外，不同类型的对象不能进行相等比较。具有不同标识的类的实例比较结果通常为不相等，除非类定义了 __eq__() 方法。

这里的__eq__()方法类似于C++中的操作符重载(operator ==),如若设置正确，不同类型的对象也能进行相等比较。其他的符号重载也有类似的函数。

运算符 is 和 is not 用于检测对象的标识号：当且仅当 x 和 y 是同一对象时 x is y 为真。一个对象的标识号可使用 id() 函数来确定。 x is not y 会产生相反的逻辑值

示例：

class A:
    #定义基本属性(没有下划线表示public类型)
    a = 0
    #定义私有属性(双下划线前缀表示private，单下划线表示protected)
    __b = 0
    #定义构造方法
    def __init__(self,x,y):
        self.a = x
        self.__b = y
    
    def __bool__(self):
        return self.a>0

    def __eq__(self,obj):
        return self.a == obj.a
#未定义__eq__()方法
class B:
    a = 0
    def __init__(self,x):
        self.a = x
class C:
    a = 0
    def __init__(self,x):
        self.a = x

a = A(-1,5)
if a:
    print(1)
else:
    print(-1)

a1 = a5 =  A(1,6)
a2 = A(1,6)
a3 = A(2,6)
b1 = B(1)
c1 = C(1)

#同类对象实例的比较，要看__eq__()的定义
print(a1==a2)
print(a1==a3)

#比较标识，这个标识可由id()获得
print(a1 is a5)
print(id(a1))
print(id(a5))

#会调用a1中的方法
print(b1==a1)

#未定义的__eq__()的两个类，==比较得到false
print(b1==c1)

#输出:
'''
True
False
True
1523027327576
1523027327576
True
False
'''

数字类型

存在三种不同的数字类型: 整数, 浮点数 和复数。此外，布尔值属于整数的子类型。整数具有无限的精度。浮点数通常使用 C 中的 double 来实现；有关你的程序运行所在机器上浮点数的精度和内部表示法可在 sys.float_info 中查看。复数包含实部和虚部，分别以一个浮点数表示。要从一个复数 z 中提取这两个部分，可使用 z.real 和 z.imag。

迭代器类型

Python 支持在容器中进行迭代的概念。这是通过使用两个单独方法来实现的；它们被用于允许用户自定义类对迭代的支持

容器对象要提供迭代支持，必须定义一个方法:container.__iter__()。这个方法返回一个迭代器对象。该对象需要支持迭代器协议。如果容器支持不同的迭代类型，则可以提供额外的方法来专门地请求不同迭代类型的迭代器。

迭代器对象自身需要支持以下两个方法，它们共同组成了 迭代器协议:

iterator.__iter__()，返回迭代器对象本身。
iterator.__next__()，从容器中返回下一项。

类似于C++的迭代器，迭代器就是访问容器接扣。通过迭代器，顺序访问容器的元素。

序列类型

有三种基本序列类型：list, tuple 和 range 对象。

通用序列操作

运算	结果
`x in s`	如果 s 中的某项等于 x 则结果为 `True`，否则为 `False`
`x not in s`	如果 s 中的某项等于 x 则结果为 `False`，否则为 `True`
`s + t`	s 与 t 相拼接
`s * n` 或 `n * s`	相当于 s 与自身进行 n 次拼接
`s[i]`	s 的第 i 项，起始为 0
`s[i:j]`	s 从 i 到 j 的切片
`s[i:j:k]`	s 从 i 到 j 步长为 k 的切片
`len(s)`	s 的长度
`min(s)`	s 的最小项
`max(s)`	s 的最大项
`s.index(x[, i[, j]])`	x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）
`s.count(x)`	x 在 s 中出现的总次数

列表

通常用于存放同类项目的集合（其中精确的相似程度将根据应用而变化）。

可以用多种方式构建列表：

使用一对方括号来表示空列表: []
使用方括号，其中的项以逗号分隔: [a], [a, b, c]
使用列表推导式: [x for x in iterable]
使用类型的构造器: list() 或 list(iterable)

iterable 可以是序列、支持迭代的容器或其它可迭代对象。

示例：

#空元组
a = []
b = [1,2,3]
#利用列表推导
c = [x for x in range(0,6)]
#利用类型的构造器
d = list()
print(a)
print(b)
print(c)
print(d)
#输出
'''
[]
[1, 2, 3]
[0, 1, 2, 3, 4, 5]
[]
'''

元组

通常用于储存异构数据的多项集

可以用多种方式构建元组：

使用一对圆括号来表示空元组: ()
使用一个后缀的逗号来表示单元组: a, 或 (a,)
使用以逗号分隔的多个项: a, b, c or (a, b, c)
使用内置的 tuple(): tuple() 或 tuple(iterable)

其构造方法与列表类似。

range对象

range 类型表示不可变的数字序列，通常用于在 for 循环中循环指定的次数。

class range(stop)

class range(start, stop[, step])

这是它的两个构造器。

range 构造器的参数必须为整数（可以是内置的 int 或任何实现了 __index__ 特殊方法的对象）。如果省略 step 参数，其默认值为 1。如果省略 start 参数，其默认值为 0，如果 step 为零则会引发 ValueError。

如果 step 为正值，确定 range r 内容的公式为 r[i] = start + step*i 其中 i >= 0 且 r[i] < stop。

如果 step 为负值，确定 range 内容的公式仍然为 r[i] = start + step*i，但限制条件改为 i >= 0 且 r[i] > stop.

与C++类似，表示的左闭右开区间。即元素在[start,stop)之间。

# range对象
a = list(range(0,10,2))
b = list(range(11))
print(a) 
print(b) 
#输出
'''
[0, 2, 4, 6, 8]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
'''

文本序列类型-str

在 Python 中处理文本数据是使用 str 对象，也称为 字符串。字符串是由 Unicode 码位构成的不可变序列。字符串字面值有多种不同的写法：

单引号: '允许包含有 "双" 引号'
双引号: "允许包含有 '单' 引号"。
三重引号: '''三重单引号''', """三重双引号"""

使用三重引号的字符串可以跨越多行 —— 其中所有的空白字符都将包含在该字符串字面值中。

字符串的方法

略，比C++的丰富的多。

集合类型

包含set,frozenset。常见的用途包括成员检测、从序列中去除重复项以及数学中的集合类计算，例如交集、并集、差集与对称差集等等。作为一种无序的多项集，集合并不记录元素位置或插入顺序。相应地，集合不支持索引、切片或其他序列类的操作。

set 类型是可变的 — 其内容可以使用 add() 和 remove() 这样的方法来改变。由于是可变类型，它没有哈希值，且不能被用作字典的键或其他集合的元素。 frozenset 类型是不可变并且为 hashable — 其内容在被创建后不能再改变；因此它可以被用作字典的键或其他集合的元素。

构造方式

class set([iterable])

class frozenset([iterable])

示例：

#set 
a = set([1,1,2,2,4,5,6,7])
print(a)
#输出：
'''
{1, 2, 4, 5, 6, 7}
'''

映射类型

dict–字典(一对一映射)

mapping 对象会将 hashable 值映射到任意对象。映射属于可变对象。字典的键几乎可以是任何值。非 hashable 的值，即包含列表、字典或其他可变类型的值（此类对象基于值而非对象标识进行比较）不可用作键。数字类型用作键时遵循数字比较的一般规则：如果两个数值相等 (例如 1 和 1.0) 则两者可以被用来索引同一字典条目。（但是请注意，由于计算机对于浮点数存储的只是近似值，因此将其用作字典键是不明智的。）

字典可以通过将以逗号分隔的 键: 值 对列表包含于花括号之内来创建，例如: {'jack': 4098, 'sjoerd': 4127} 或 {4098: 'jack', 4127: 'sjoerd'}，也可以通过 dict 构造器来创建。

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

所支持的操作：略。详见python参考文档。

# 在前的为键（key),在后的为映射值
# 此处的例子是'a','b'为键，1,2映射值
a = {'a':1,'b':2}
# 会以用花括号构造的方式打印字典
print(a)
#返回所有键值
print(list(a))
print(a['b'])

# 其他构造方式
a = dict(one=1, two=2, three=3)
c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
d = dict([('two', 2), ('one', 1), ('three', 3)])
e = dict({'three': 3, 'one': 1, 'two': 2})
print(a)
print(c)
print(d)
print(e)

'''输出
{'a': 1, 'b': 2}
['a', 'b'] 
2
{'one': 1, 'two': 2, 'three': 3}
{'one': 1, 'two': 2, 'three': 3}
{'two': 2, 'one': 1, 'three': 3}
{'three': 3, 'one': 1, 'two': 2}
'''