Python での 4 つの主要なデータ型の例を分析する

基本データ型

数値型

Python のデータは、よく知られている int 整数オブジェクト、float 倍精度浮動小数点型、bool 論理オブジェクトなど、すべてのオブジェクトです。すべては単一の要素です。例を 2 つ挙げてください。

プレフィックス 0x を付けて 16 進整数を作成します:

0xa5 # 等于十进制的 165

e を使用して科学表記法で表される浮動小数点数を作成します:

1.05e3 # 1050.0

コンテナ タイプ

複数の要素を収容できるコンテナ オブジェクト。一般的に使用されるものには、リスト リスト オブジェクト、タプル タプル オブジェクト、辞書辞書オブジェクト、セット コレクション オブジェクトなどがあります。 Python は、これらのタイプの変数を非常に簡潔な構文で定義します。

例は次のとおりです。

角かっこ [] のペアを使用してリスト変数を作成します:

lst = [1,3,5] # list 变量

図からわかるように、右側のコンテナは開ループです。これは、コンテナが次の要素の追加と削除を行うことができることを意味します:

一対のかっこ () を使用してタプル オブジェクトを作成します:

tup = (1,3,5) # tuple 变量

図に示すように、右側のコンテナは閉じられています。つまり、タプルが作成されると、要素をコンテナに追加したりコンテナから削除したりすることはできません。

ただし、単一の要素を含むタプルをタプルとして解釈するには、カンマを残す必要があることに注意してください。

tup = (1,) # 必须保留逗号

それ以外の場合は要素自体とみなされます:

In [14]: tup=(1)
   ...: print(type(tup)) 
<class &#39;int&#39;>

一対の中括弧 {} を使用し、コロン : を使用して作成しますdict オブジェクト:

dic = {'a':1, 'b':3, 'c':5} # dict变量

辞書はハッシュ テーブルです。次の図は辞書の「形」を鮮やかに表しています。

中括弧のペア {} のみを使用してセット オブジェクトを作成します:

s = {1,3,5} # 集合变量

Python コンテナ タイプ、リスト、辞書、tuple、set などを使用すると、強力な関数を簡単に実装できます。

1. 平均を求める

リスト内の最小値と最大値を削除した後、残りの要素の平均を計算します。

def score_mean(lst):
   lst.sort()
   lst2=lst[1:-1]
   return round((sum(lst2)/len(lst2)),1)

lst=[9.1, 9.0,8.1, 9.7, 19,8.2, 8.6,9.8]
score_mean(lst) # 9.1

コード実行プロセス、アニメーションのデモ:

2. 99 の九九を印刷します

次の形式の乗算表:

1*1=1
1*2=2   2*2=4
1*3=3   2*3=6   3*3=9
1*4=4   2*4=8   3*4=12  4*4=16
1*5=5   2*5=10  3*5=15  4*5=20  5*5=25
1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36
1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49
1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64
1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81

には合計 10 行があります。i 番目の行の j 番目の列は、次と同じです: j*i、ここで:

• i 値の範囲: 1<=i<=9

• j 値の範囲: 1<=j&lt ;=i

「分析例」の言語説明によると、

In [13]: for i in range(1,10):
   ...:     for j in range(1,i+1):
   ...:         print('%d*%d=%d'%(j,i,j*i),end='\t')
   ...:     print()

3 というコードに変換されます。サンプリング

サンプル サンプリング を使用します。次の例では、100 個のサンプルからランダムに 10 個のサンプルをサンプリングします。

from random import randint,sample
lst = [randint(0,50) for _ in range(100)]
print(lst[:5])# [38, 19, 11, 3, 6]
lst_sample = sample(lst,10)
print(lst_sample) # [33, 40, 35, 49, 24, 15, 48, 29, 37, 24]

String

Python には C のような文字型 (char) がなく、すべての文字または文字列は str オブジェクトに統一されることに注意してください。たとえば、単一文字 c の型も str です。

よく使われるstr型ですが、まずはよく使うメソッドを5つ挙げてみましょう。

strip は文字列の前後のスペースを削除するために使用されます:

In [1]: '  I love python\t\n  '.strip()
Out[1]: 'I love python'

replace は文字列を置換するために使用されます:

In [2]: 'i love python'.replace(' ','_')
Out[2]: 'i_love_python'

join は文字列をマージするために使用されます:

In [3]: '_'.join(['book', 'store','count'])
Out[3]: 'book_store_count'

title は、単語の最初の文字を大文字にするために使用されます。

In [4]: 'i love python'.title()
Out[4]: 'I Love Python'

find は、一致する文字列の開始位置インデックスを返すために使用されます。

In [5]: 'i love python'.find('python')
Out[5]: 7

文字列を適用する例として、 str1 が回転された str2 で構成されているかどうかを判断します。

文字列 stringbook を回転して bookstring を取得します。str1 が回転して得られた str2 であるかどうかを確認するコードを記述します。

判定に変換: str1 が str2 str2 の部分文字列であるかどうか。

下面函数原型中，注明了每个参数的类型、返回值的类型，增强代码的可读性和可维护性。

def is_rotation(s1: str, s2: str) -> bool:
   if s1 is None or s2 is None:
       return False
   if len(s1) != len(s2):
       return False

   def is_substring(s1: str, s2: str) -> bool:
       return s1 in s2
   return is_substring(s1, s2 + s2)

测试函数 is_rotation：

r = is_rotation('stringbook', 'bookstring')
print(r)  # True

r = is_rotation('greatman', 'maneatgr')
print(r)  # False

代码执行过程，动画演示：

55555

字符串的匹配操作除了使用 str 封装的方法外，Python 的 re 正则模块功能更加强大，写法更为简便，广泛适用于爬虫、数据分析等。

下面这个案例实现：密码安全检查，使用正则表达式非常容易实现。

密码安全要求：

• 要求密码为 6 到 20 位；

• 密码只包含英文字母和数字。

import re
pat = re.compile(r'\w{6,20}') # 这是错误的，因为 \w 通配符匹配的是字母，数字和下划线，题目要求不能含有下划线
# 使用最稳的方法：\da-zA-Z 满足“密码只包含英文字母和数字”
# \d匹配数字 0-9
# a-z 匹配所有小写字符；A-Z 匹配所有大写字符
pat = re.compile(r'[\da-zA-Z]{6,20}')

选用最保险的 fullmatch 方法，查看是否整个字符串都匹配。

以下测试例子都返回 None，原因都在解释里。

pat.fullmatch('qaz12') # 返回 None，长度小于 6
pat.fullmatch('qaz12wsxedcrfvtgb67890942234343434') # None 长度大于 22
pat.fullmatch('qaz_231') # None 含有下划线

下面这个字符串 n0passw0Rd 完全符合：

In [20]: pat.fullmatch('n0passw0Rd')
Out[20]: <re.Match object; span=(0, 10), match=&#39;n0passw0Rd&#39;>

自定义类型

Python 使用关键字 class 定制自己的类，self 表示类实例对象本身。

一个自定义类内包括属性、方法，其中有些方法是自带的。

类（对象）：

class Dog(object):
   pass

以上定义一个 Dog 对象，它继承于根类 object，pass 表示没有自定义任何属性和方法。

下面创建一个 Dog 类型的实例：

wangwang = Dog()

Dog 类现在没有定义任何方法，但是刚才说了，它会有自带的方法，使用 dir() 查看这些自带方法：

In [26]: wangwang.__dir__()
Out[26]:
['__module__',
'__dict__',
'__weakref__',
'__doc__',
'__repr__',
'__hash__',
'__str__',
'__getattribute__',
'__setattr__',
'__delattr__',
'__lt__',
'__le__',
'__eq__',
'__ne__',
'__gt__',
'__ge__',
'__init__',
'__new__',
'__reduce_ex__',
'__reduce__',
'__subclasshook__',
'__init_subclass__',
'__format__',
'__sizeof__',
'__dir__',
'__class__']

有些地方称以上方法为魔法方法，它们与创建类时自定义个性化行为有关。比如：

• init 方法能定义一个带参数的类；

• new 方法自定义实例化类的行为；

• getattribute 方法自定义读取属性的行为；

• setattr 自定义赋值与修改属性时的行为。

类的属性：

def __init__(self, name, dtype):
    self.name = name
    self.dtype = dtype

通过 init，定义 Dog 对象的两个属性：name、dtype。

类的实例：

wangwang = Dog('wangwang','cute_type')

wangwang 是 Dog 类的实例。

类的方法：

def shout(self):
   print('I\'m %s, type: %s' % (self.name, self.dtype))

注意：

• 自定义方法的第一个参数必须是 self，它指向实例本身，如 Dog 类型的实例 dog；

• 引用属性时，必须前面添加 self，比如 self.name 等。

总结以上代码：

In [40]: class Dog(object):
   ...:     def __init__(self,name,dtype):
   ...:         self.name=name
   ...:         self.dtype=dtype
   ...:     def shout(self):
   ...:         print('I\'m %s, type: %s' % (self.name, self.dtype))

In [41]: wangwang = Dog('wangwang','cute_type')

In [42]: wangwang.name
Out[42]: 'wangwang'

In [43]: wangwang.dtype
Out[43]: 'cute_type'

In [44]: wangwang.shout()
I'm wangwang, type: cute_type

看到创建的两个属性和一个方法都被暴露在外面，可被 wangwang 调用。这样的话，这些属性就会被任意修改：

In [49]: wangwang.name='wrong_name'
   
In [50]: wangwang.name
Out[50]: 'wrong_name'

如果想避免属性 name 被修改，可以将它变为私有变量。改动方法：属性前加 2 个 _ 后，变为私有属性。如：

In [51]: class Dog(object):
   ...:     def __init__(self,name,dtype):
   ...:         self.__name=name
   ...:         self.__dtype=dtype
   ...:     def shout(self):
   ...:         print('I\'m %s, type: %s' % (self.name, self.dtype))

同理，方法前加 2 个 _ 后，方法变为“私有方法”，只能在 Dog 类内被共享使用。

但是这样改动后，属性 name 不能被访问了，也就无法得知 wangwang 的名字叫啥。不过，这个问题有一种简单的解决方法，直接新定义一个方法就行：

def get_name(self):
   return self.__name

综合代码：

In [52]: class Dog(object):
   ...:     def __init__(self,name,dtype):
   ...:         self.__name=name
   ...:         self.__dtype=dtype
   ...:     def shout(self):
   ...:         print('I\'m %s, type: %s' % (self.name, self.dtype))
   ...:     def get_name(self):
   ...:         return self.__name
   ...:

In [53]: wangwang = Dog('wangwang','cute_type')

In [54]: wangwang.get_name()
Out[54]: 'wangwang'

但是，通过此机制，改变属性的可读性或可写性，怎么看都不太优雅！因为无形中增加一些冗余的方法，如 get_name。

下面，通过另一个例子，解释如何更优雅地改变某个属性为只读或只写。

自定义一个最精简的 Book 类，它继承于系统的根类 object：

class Book(object):
   def __init__(self,name,sale):
       self.__name = name
       self.__sale = sale

使用 Python 自带的 property 类，就会优雅地将 name 变为只读的。

   @property
   def name(self):
       return self.__name

使用 @property 装饰后 name 变为属性，意味着 .name 就会返回这本书的名字，而不是通过 .name() 这种函数调用的方法。这样变为真正的属性后，可读性更好。

In [101]: class Book(object):
    ...:     def __init__(self,name,sale):
    ...:         self.__name = name
    ...:         self.__sale = sale
    ...:     @property
    ...:     def name(self):
    ...:         return self.__name

In [102]: a_book = Book('magic_book',100000)

In [103]: a_book.name
Out[103]: 'magic_book'

property 是 Python 自带的类，前三个参数都是函数类型。更加详细的讨论放在后面讨论装饰器时再展开。

In [104]: help(property)
Help on class property in module builtins:

class property(object)
|  property(fget=None, fset=None, fdel=None, doc=None)

如果使 name 既可读又可写，就再增加一个装饰器 @name.setter。

In [105]: class Book(object):
    ...:     def __init__(self,name,sale):
    ...:         self.__name = name
    ...:         self.__sale = sale
    ...:     @property
    ...:     def name(self):
    ...:         return self.__name
    ...:     @name.setter
    ...:     def name(self,new_name):
    ...:         self.__name = new_name

In [106]: a_book = Book('magic_book',100000)

In [107]: a_book.name = 'magic_book_2.0'

In [108]: a_book.name
Out[108]: 'magic_book_2.0'

注意这种装饰器写法：name.setter，name 已经被包装为 property 实例，调用实例上的 setter 函数再包装 name 后就会可写。对于 Python 入门者，可以暂时不用太纠结这部分理论，使用 Python 一段时间后，再回过头来自然就会理解。

以上がPython での 4 つの主要なデータ型の例を分析するの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。