Notes on learning Python（2）——数据类型

男娘i 2022-03-08 10:44 154阅读 0赞

### 文章目录 ###

*  序列
 *   *  索引操作符 \[ num \]
     *  切片操作符 \[ num1 : num2 : num3\]
     *  基本操作
 *  数据类型
 *   *  数字
     *   *  整型int
         *  长整型long
         *  浮点型float
         *  复数型complex
     *  字符串
     *   *  字符串的索引
         *  字符串的切片
     *  列表\[ \]
     *   *  创建列表
         *  列表的操作
     *  元组（）
     *   *  创建元组
         *  元组的拆分
     *  字典\{ \}
     *   *  字典的操作
 *  help

# 序列 #

序列包括：**字符串、列表、元组**  
序列的两个特点：

## 索引操作符 \[ num \] ##

**从序列中抓取特定项目**  
索引可以是正数也可以是负数  
做负数时位置是从序列尾开始计数

例
    str1 = ‘abcd’
    str1[0] = a
    str1[-1] = d  #-1 是字符串最后一个元素

## 切片操作符 \[ num1 : num2 : num3\] ##

**获取序列的一部分（切片）**  
切片操作符是序列后跟一个带有冒号的方括号及 \[ num1 : num2\]  
num1是切片开始的位置，num2为切片结束的位置但不包括这个位置,num3是步长值，默认为1可省略  
若没有num1时，序列从首位置开始切片  
若没有num2时，切片截止到尾位置  
切片操作符中首个冒号不可省略

## 基本操作 ##

<table> 
 <thead> 
  <tr> 
   <th>操作符</th> 
   <th>意义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>len()</td> 
   <td>求序列长度</td> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>连接两个序列</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>重复序列元素</td> 
  </tr> 
  <tr> 
   <td>in</td> 
   <td>判断元素是否在序列中</td> 
  </tr> 
  <tr> 
   <td>max</td> 
   <td>返回最大值</td> 
  </tr> 
  <tr> 
   <td>min</td> 
   <td>返回最小值</td> 
  </tr> 
  <tr> 
   <td>cmp(tuple1,tuple2)</td> 
   <td>比较序列值是否相同</td> 
  </tr> 
 </tbody> 
</table>

注：  
in操作为真时返回 True 假为False  
cmp（）操作 前一个序列值大于后一个序列值时为1，小于时为-1，等于时为0  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70]

# 数据类型 #

## 数字 ##

### 整型int ###

整数**int**的范围是： -2，147，483，648 到 2，147，483，647  
**例程：**

>>> num= 2147483647
    >>> type(num)
     <type'int'>

### 长整型long ###

长整型**long**可以存储任意大的整数  
为了区分整型与长整型，需在数字后面添加‘L’或者‘l’  
**例程：**

>>>num = 9999999999999999999 
    >>>type(num)
     <type'long'>
    >>>num = 2333L
    >>>type(num)
     <type'long'>

### 浮点型float ###

>>> f1 = 0.1
    >>> type(f1)
    <type'float'>

### 复数型complex ###

python对复数提供内嵌支持  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 1]

## 字符串 ##

使用引号包含数字、字母、符号的集合

Strval = 'Great'
    Strval = ''Great''
    Strval = '''Great'''

**三重引号制作字符串**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 2]

### 字符串的索引 ###

a = 'ABCD'
    b ='abcd'
    a[0] = A
    b[0] = a
    a[0]+ b[0] = Aa

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 3]

### 字符串的切片 ###

a = 'abcdefg'
    a[1:4]
    <bcd>  #取的是字符串第二个开始取字符到第五个字符前一个字符

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 4]

a = 'abcdefg'
    a[0:6:2]
    <ace>  #在第1个到第6个字符中每隔两个取一个字符

负数也是这个道理  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 5]

## 列表\[ \] ##

*  列表用方括号规范元素。元素可以是字符串也可以是数字，元素之间用逗号隔开。
 *  列表list是处理一组有序项目的数据结构，在列表中存储有序的项目数据。
 *  列表存储的项目数据是可变的
 *  可对列表进行索引和切片
 *  对列表元素进行赋值时，其地址是不变的

### 创建列表 ###

*  空列表

list = []

*  单元素列表

list = [element]

*  一般列表

List1 = ['family'，'friend'，'money']
    List2 = [1,2,3,4,5]
    List3 = ["str1","str2","str3"]

### 列表的操作 ###

<table> 
 <thead> 
  <tr> 
   <th>添加</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>list.append( )</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>删除第一个元素</th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>list.remove( list[ ] ) )</td> 
   <td>del( list[ ]</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>移除列表中最后一个元素（默认），并返回该元素的值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>list.pop([index=-1]）</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>将对象插入列表</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>list.insert(index, element)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>反向列表中元素</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>list.reverse()</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>对原列表进行排序</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>list.sort(cmp=None, key=None, reverse=False)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>统计元素出现的次数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>list.count(element)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>元组转换成列表</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>list [tuple ]</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>列表扩展列表</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>list.extend(list[num1,num2])</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>定位某元素第一次出现的位置</th> 
   <th>-</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>list.index(element)</td> 
   <td>-</td> 
  </tr> 
 </tbody> 
</table>

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 6]

## 元组（） ##

*  元组与列表类似，但是元组与字符串一样不可修改
 *  元组通过逗号将括号内的项目隔开，通常用在使语句和自定义函数唯一，即被使用的元组的值不变
 *  在对元组元素进行赋值时，赋值前后其地址是不同的

### 创建元组 ###

*  空元组  
    由一对空的圆括号组成  
    例：

empty = （）

*  单个元素元组(逗号不可省略)

single = (2，)

*  一般元组

general = （'family'，'friend'，'money'）

general = （'family'，'friend'，'money'）
    general[1] = 'girlfriend'
    由于元组内容固定，不可通过上述操作对元组内容进行更改

**元组和字符串一样属于序列类型，可通过索引和切片操作**，这里不过多解释。

### 元组的拆分 ###

定义一个元组，元组内有n个元素，通过元组的拆分可将这n个元素分别赋予n个变量

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 7]  
列表和元组能实现对数据的索引和切片

input:
    list = ['HBX_1024','24','male']
    output:
    list[0] = 'HBX_1024'

但是不能直接实现

list[name] = 'HBX_1024'

即使遍历列表也达不到映射的效果

input:
    list = ['name','age', 'gender']
    list1 = ['HBX_1024','24','male']
    zip(list,list1)#遍历列表，将两个列表变为元组
    output:
    [('name','HBX_1024'),('age','24'),('gender','male')]

这是就需要用字典来解决此类问题。

## 字典\{ \} ##

*  字典是**python**中**惟一**的**映射**类型（哈希表）
 *  字典存储的数据是**无序**的
 *  字典**对象**是**可变**的，但是字典的**键** key 必须使用 **不可变对象**
 *  字典中可使用不同类型的键值
 *  **values()** 或者 **keys()** 返回值列表或者键列表
 *  **items()** 返回包含键值对应的元组

形式：

dic = {key1 : 'a' ,key2 : 'b' ,key3 : 'c' ,key4 : 'd' }
    dic[key1] = a
    dic[key2] = b
    dic[key3] = c
    dic[key4] = d

![字典][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 8]

### 字典的操作 ###

**更新和删除：**

1.  直接用键值访问更新；内建的update()方法可以将整个字典的美容拷贝到另一个字典中。
2.

del dict['a']#删除字典中键值为a的元素
    	dic.pop('a')#删除并返回键值为‘a’的元素
    	dic.clear()#删除字典所有的元素
     	del dict#删除整个字典

![操作][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 9]

1.  内建函数
    
     *  type()\#查看类型
     *  str()\#生成大字符串
     *  cmp()\#依次比较字典的大小、键、值
2.  工厂函数dict()

*  例如：dict(zip(‘x’,‘y’),(1,2)) 或 dict(x = 1,y = 2)
 *  \{‘y’:2,‘x’:1\}
 *  使用字典生成字典比用copy慢，推荐使用copy()

<table> 
 <thead> 
  <tr> 
   <th>常用操作</th> 
   <th>–</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>len()</td> 
   <td>长度</td> 
  </tr> 
  <tr> 
   <td>hash()</td> 
   <td>判断对象是否可做键</td> 
  </tr> 
  <tr> 
   <td>dict.clear()</td> 
   <td>清空字典</td> 
  </tr> 
  <tr> 
   <td>dict.fromkeys(seq,val = None)</td> 
   <td>以seq中的元素为键创建并返回一个字典，val 为默认值</td> 
  </tr> 
  <tr> 
   <td>dict.get(key,default = None)</td> 
   <td>返回key的value，若不存在返回default指定值</td> 
  </tr> 
  <tr> 
   <td>dict.has_key(key)</td> 
   <td>判断字典是否存在key，可用in，not in代替</td> 
  </tr> 
  <tr> 
   <td>dict.items()</td> 
   <td>返回键值对元组的列表</td> 
  </tr> 
  <tr> 
   <td>dict.keys</td> 
   <td>返回字典中键的列表</td> 
  </tr> 
  <tr> 
   <td>dict.iter*()</td> 
   <td>–</td> 
  </tr> 
  <tr> 
   <td>dic.pop(key[,default])</td> 
   <td>–</td> 
  </tr> 
  <tr> 
   <td>dict.setdefault(key,default = None)</td> 
   <td>–</td> 
  </tr> 
  <tr> 
   <td>dict.update(dic2)</td> 
   <td>将dict2中的键值对添加到字典dict中</td> 
  </tr> 
  <tr> 
   <td>dict.values()</td> 
   <td>返回字典中所有值的列表</td> 
  </tr> 
 </tbody> 
</table>

# help #

对于不清楚函数的意义和用法可以用**help( )** 来查询。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70]: /images/20220308/6c33588dc7db4f7aba8043885e6cb9ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 1]: /images/20220308/a9b8e050b52345dea9e4f798b585ce9d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 2]: /images/20220308/4db42b3ee74344e1b7b559fe0fc6ccdb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 3]: /images/20220308/0f4f514bb9de47bdaa5bf1568d5e8be1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 4]: /images/20220308/5a6f188f38934756b350457e4fdc4b5b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 5]: /images/20220308/6884c6818bfa4ae7ade4680dfeedd727.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 6]: /images/20220308/8d323f60f40e4b91bfff180e1523af2e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 7]: /images/20220308/bf1caa880fcd43fb9736f68b336b56ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 8]: /images/20220308/2c12213ea8b8426d84ea92cc468d5252.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODYwNzI4_size_16_color_FFFFFF_t_70 9]: /images/20220308/4d96eece92034c69b610e6d359ef2c6e.png