python数据类型和循环控制

来源：互联网发布：洪金宝范冰冰知乎编辑：程序博客网时间：2024/06/01 09:42

变量

变量名 = 变量值 # = 绑定；变量名（标识符）映射变量值，当定义一个变量时，解释器开辟一块儿内存空间，存入变量的值。也可以说，变量名指向值在内存中的地址。

内存回收

没有绑定关系的变量值被回收，即值的引用计数器为0时，python解释器会自动回收该值。
当变量名绑定新的值时，原来的值无绑定，被回收。
一个值可以绑定多个变量名
del 变量名 # 解除绑定
id(变量名) # 查看变量绑定值所在的内存地址的id号
比较短的值，像小整数，占用的内存空间小，python解释器会将它们缓存在内存中，一旦再有变量被赋值为小整数，就可以直接引用。比较长的值，不会缓存在内存中，每次定义一个变量，都会开辟新的内存空间。

输入输出

input() # 括号内可以写提示信息。在python3中，默认所有的输入被转为字符串。在python2中，用户输入什么类型就是什么类型，输入字符串时要加‘ ‘，告知input输入类型。python3中的input()《==相当于==》python2中的raw_input()。
在windows命令行窗口中，可以通过import getpass 来输入用户密码时不显示密码 password = getpass.getpass('密码')
type(变量) # 显示变量类型
print('......', abc) 与print('.....%s.....', abc) # 使用%d(整数)、%f(浮点数)、%s(字符串)这些占位符，可以更灵活的打印变量

运算符

算术运算符：+、-、*、/、//(取整除)、**(幂的运算，e.g. 7**2表示7的2次幂)、%
赋值运算：= 、+=、-、-=、*=、/=、%=、**=、//=
比较运算符：==、！=、>、>=、<、<=
逻辑运算符：and、or、not
关系运算符：

文件头与注释

# -*- coding: utf-8 -*- 指定字符编码方式
# 单行注释；''' '''多行注释

python中的数据类型：

即变量的值的类型：

数字类型：int、float、bool、复数（注意：python2中还有long lint，python3中int长度无限制）
- 科学计数法：e.g. 1.3e5 ------> 1.3 * 10^5
- bin(int): 转二进制；标识：0b
  oct(int): 转八进制；标识：0o
  hex(jbin): 转16进制；标识0x
- 特性：一经定义，值不可更改（即，改变值必须改变内存地址）；直接访问
字符串类型：
- ‘ ’‘ ’‘’ 三种引号引起来的都是字符串
- 常用操作：
  - x.strip() # 默认去空格，也可以去括号内指定的字符
  - x.split() # 分割字符串为列表，默认以空格分割，具体可以根据字符串的特征选取分隔符
  - ' '.join(字符串列表) # 引号内可以指定连接符。
  - x.isdigit() # 判断字符串是否是整数。可以用来判断用户输入是否符合要求
```
age = input('请输入年纪：')if age.isdigit():    age_new = int(age)   #将用户输入的字符串转化为int ；如果不加判断的转化，一旦用户输入了非数字的字符串，那么int()转化将导致错误。    print(age_new, type(age_new))请输入年纪：2020 <class 'int'>
```
  - x.format() # 格式化字符串：
```
string = 'a:{}, b:{}, c:{}'x = string.format(100, 90, 80)print(x)
```
```
a:100, b:90, c:80
```
```
person = 'name:{x}, gender:{y}, age:{z}'x = person.format(x='tom',y='male',z='20')print(x)
```
```
name:tom, gender:male, age:20
```
  - x.place() # 替换字符串。替换并不会改变原值，除非重新赋值
```
string = 'ich liebe das world'print(string.replace('das','die'))ich liebe die world
```
  - x.startswith() #以括号内字符开头，判断真假
  - x.endswith() #以括号内字符结尾，判断真假
  - x.find() # 查找，结果以index号显示
  - x.index() # 显示字符串中某个字符的index号，配合切片使用
  - x.[ : : ] # 切片起始：结束：步长
```
s = 'das gerne ich, aber kann ich nicht'print(s[s.index('k')])   #找到字母k的索引号，然后用切片的方式打印出来k
```
  - x.count() # 计算括号内字符出现的次数
  - x.capitalize() #首字母大写
  - x.upper() # 所有字母大写
  - x.lower() # 所有字母小写
  - x.title() #标题，判断首字母是否大写，如果不是自动大写
  - x.ljust()左对齐, 括号内指定缩进和填充符
```
s = 'als'print(s.ljust(10,'*'))als*******
```
  - x.rjust() # 右对齐
  - x.center() # 居中
```
s = 'als'print(s.center(10,'*'))***als****
```

列表：逗号分隔多个元素，元素可以是任意类型
定义一个列表：l = [1, 'a', [3, 4]] # l = list([1, 'a', [3, 4]])
- 取值 l[index], 同字符串，都是有序的
- 遍历：
  - 方法一：for i in l:
  - 方法二：
```
count = 0while count < len(l):     print(l[count])     count += 1
```
- l.append(元素) # 默认追加到最后面
- l.insert(index) # 插入括号内指定位置，默认插在最前面
- l.pop(index) # 括号内填入index, 指定要删除的元素；不加index,默认删除最后一个元素，相当于pop(-1)。另外，该命令有返回值：返回刚刚删除的值。
- 队列与堆栈的模拟：
  - 队列：先进先出：l.append()===>l.pop(0) 或 l.insert()====>l.pop()
  - 堆栈：先进后出(后进先出）：l.append()=====>l.pop()
- len(l) #统计队列长度
- l.index(元素）#查索引
- l.count(元素) #查元素的个数
- l.extend([列表]) # 合并列表。不同于append, 后者是把列表作为一个元素追加入原列表
- l.remove(元素）删除元素，如果有多个重复元素，只删除第一个。（pop是按索引来删）
- l.sort() # 默认从小到大。排序不像pop有返回值
- l.sort(reverse = True) # 先按大小排序，再反转
- l.reverse()# 反转（没有比较大小的属性）
- 包含（也适用于字符串）：元素 in 列表中，返回True/False
```
s = 'lena is smart'print('lena' in s)True
```

元组：有序，不可变。定义一个元组 t =(元素1，元素2，#元素可以是任意类型，所以可以嵌套列表，修改里面列表的元素)
- t.count(元素) 计数
- t.index(元素）
- t[index] 索引
- t[::]切片、长度、包含
字典：d={key1:value1, key2:value2} key value用冒号分隔
- key必须是不可变类型（数字、字母、元组、或者说可hash类型，hash() 括号内传入不可变对象，hash校验出一个值）。
- vaue可以是任意类型数据。
- 字典的取值：d[key] 字典是无序的（no index)
- 字典的修改：d[key] = value_new
- 字典的循环：d.keys() 提取key d.values() 提取value
- 迭代器遍历字典：这种方法不通过索引，对于列表，元组，字符串，将取出元素，对于字典，取出key
```
for k in d:    print(k, d(k))
```
- d.get(key) vs d[key]：后者在key不存在的情况下，会报错。前者不会，这样程序不会崩溃。
集合：set
定义集合：s = {...} ==> s = set({...}) 调用set工厂函数
- 集合的特点：
  - 集合内的元素是唯一的：自动去重
  - 集合内的元素必须是可hash的，也就是不可变类型
  - 集合是无序的，无索引。但是可以遍历：for i in set
- 集合的作用：作关系运算
  - s1 & s2 取交集 ===> s1.intersection(s2)
  - s1 | s2 取并集 ===> s1.union(s2)
  - s1 - s2 取差集：在s1，不在s2 ===> s1.difference(s2)
  - s2 - s1 取差集：在s2，不在s1 ====> s2.difference(s1)
  - s1 ^ s2 取对称差集（不在交集中的）===> s1.sysmmetic_difference(s2)
- 常用的操作：
  - s.clear() 清空
  - s1.update(s2) s2的值并入s1
  - s1.difference_update(s2) 求与s2的差集，并把差集部分覆盖写入s1
```
s1 ={ 1, 2, 3, 4, 6}s2 = {1, 5, 6, 2}s1.difference_update(s2)print(s1)结果是：{3, 4}
```
  - s1.update(s2) s2的值加入s1
  - s.add(元素）增加元素
  - s.remove() 删除元素，如果元素不存在报错
  - s.discard(元素) 删除元素，如果元素不存在不报错，better than remove
  - s.pop() 随机删（因为集合是无序的）
  - s1.issubset(s2) s1是s2的子集，返回bool值
  - s1.issuperset(s2) s1是s2的父级，返回bool值
  - s1.isdisjoint(s2) 没有交集返回True

bool值：True & False
- 产生bool值：比较运算、成员运算（if m in n: ）
- 所有数据类型都自带bool值
- 数据类型返回False的情况：0、None、空（例如：空列表）；其余情况都是True
变量的三种比较：
每种数据类型都是一个类，每个类都有方法，对象调用方法用 . 点。e.g. a = 1 (a = int(1),创建一个整型数，就调用int方法，把1传入===》工厂函数（批量生产)；同样的 s = 'abc' 即s = str(abc), str也是工厂函数
几种赋值：
- x =1 赋值操作，没有任何返回值
- 链式赋值：
```
a=b=c=d=e=f=10print(a,b,c,d,e,f)10 10 10 10 10 10
```
- 多元赋值：交换变量的值（C语言是通过一个中间值）
```
x = 12y = 56x,y = y,xprint(x,y)56 12
```

解压序列类型：

s = 'hello'a,b,c,d,e = s 按索引一一对应a,_,_,_,e = s  用下划线占位，只取首尾（要丢弃的值赋给_下划线）a,*_,b = s 中间都不要m,n,*_ =s 只要前两个*_,m,n = s 只要后两个a,*_ = [1, 2, 3, 4] 取列表第一个值

其它分类方式：
- 可变与不可变：一个身份id 不可变（变了内存空间就变了）；一个类型不可变（变了内存空间就变了）；而一个值可变，比如列表的值可变
  不可变对象：数字、字符、元组；可变对象：列表、字典。
  列表因为可变，内存中会预留空间，所以列表耗内存。
  字典在内存中存的has表，占用空间比列表还大，但优化了查询速度。
- 取值方式来分：直接取值：数字（通过绑定的变量名，一次取出整体）
- 序列类型：字符串、元组、列表
- 映射类型：字典

流程控制与循环结构

if 条件语句：

语句1:if 条件1:         # 判断条件1为真，则执行语句2    语句2elif:条件2:       # 判断条件2为真，则执行语句3    语句3else:    语句4         # 如果前面条件都不满足，则执行语句4语句5             # 语句5与if无关

循环语句：

while循环

while 条件:       # 条件判断为真，则执行循环体        循环体    语句1             # 循环不结束，该语句不执行break 退出当层循环continue 终止当层循环中的本次循环，进入下一次循环将while的条件设为一变量值满足某一条件为真，让这一变量值在循环体内进行自增计数，直到不满足条件为假，循环结束；tag标志位法：tag = True 赋值，while tag: 开始循环，直到某一步完成，进行tag = False，循环结束。

for循环：

for i in range(x, y, z):    语句x起始 y尾(不包括) z步长

while 和 else 连用：while循环正常结束后，即没有被continue或break打断，才能输出else内容。
for 和 else 连用，也是同样的效果。

i = 0while i < 5:    print(i,end=' ')    i += 1else:    print('循环正常结束')
运行结果：0 1 2 3 4 循环正常结束
—————————————
i = 0while i < 5: print(i,end=' ') i += 1 if i == 3: breakelse: print('循环正常结束')
运行结果：0 1 2

阅读全文

0 0