Python系统学习-02

基本数据类型

数据类型：数值用于计算，布尔值用于条件执行等等。

• 字典 是另一种可变容器模型，且可存储任意类型对象,{‘name’: morgan}，查询速度快基于二分查找，存储关系型数据
• 布尔 表示两种状态
• 字符串 是用于简单操作，凡是单，双，三引号中的数据
• 数字 用于计算
• 列表 list[1, ‘str’, true]，存储大量数据
• 元组 只读列表，只允许用户只读，存储大量数据
• 集合 关系测试

1.字符串

例子：
s = ‘I ‘m a student’(错误,也可以在‘前面添加转义字符)
s = “I ‘m a student”

1.1字符串加运算

s1=’morgan ’
s2=’xu’
print(s1+s2)——>morgan xu

1.2字符串乘运算

s1=’morgan ’
print(s1*8) ——>
morgan morgan morgan morgan morgan morgan morgan morgan

1.3字符串查询

1.3.1按索引查

s = ‘morgan xu’
s_first=[0]
s_last=[-1]

1.3.2按切片查

例子：
-6 -5 -4 -3 -2 -1 （逆向）
------------------------
 m  o  r  g  a  n （字符串）
------------------------
 0  1  2  3  4  5 （正向）

切片结果一致：
（顾首不顾尾）
s[0]==s[0:1]
s[-3:]==s[3:]
s[0:3]==s[:3]
s[:]==s[0:len(s)]
s[1:3]==s[-5:-3]==s[-5:3]==s[1:-3]
s[3:1:-1]==s[-3:-5:-1]==s[3:-5:-1]==s[-3:1:-1]
s[:1:-1]==s[:-5:-1]
s[1:1](if start_index==end_index return null)
s[-3:-4]字符串是从左往右切片，IF end_index < start_index: return null

1.3.3按切片步长：

步长不能为“零”
正向（从左向右)查找，正向查找时候start_index<end_index,否则查不到数据
s_step = s[:5:2](2:隔一个取一个)
反向取时候，反向查找时候start_index>end_index,否则查不到数据
s_reverse = s[-1:-5:-2](-2:隔一个取一个)

1.4字符串操作

例子：
s='     ab c3de*F,de,gh\t'

• s1=s.capitalize()#首字母大写**
• s2=s.swapcase()#大小写翻转**
• s3=s.title() #非字母隔开的首字母大写，就是标题的规则，每个单词第一个字母都是大写*
• s4=s.center(1) #设置总长度，并居中*
• s5=s.upper() #（lower）#转成全大写***---->用于将用户名密码转化为全大写，容易匹配
• s6=s.startswith(‘de’,5,len(s)) #用于处理筛选以'de'开始,start_index=5到end_index=len(s)之间的数据；start_index和end_index可选***
• s7=s.strip() #默认去除字符串前后的空格，换行符，制表符;用input后面一定要用此函数***
• s8=s.strip(‘de’) #自定义去除，可多次去除；只能去除带有最左和最右的字符***
• s9=s.lstrip() #去除最左面字符串***
• s10=s.rstrip() #去除最右面字符串***
• s11=s.replace(‘de’,’sb’,1) #替换old--->new--->替换次数count***
• s12=s.split(‘,’) #将字符串转化成列表；默认字符串以空格分隔，也可以用其他符号分隔***
• s13=s.split(‘,’,1) #设置分割次数***
• s14=”_”.join(l) #list（列表必须是字符串）转化成str***
• s15=s.find(‘m’, 2, 5) #find,index同过元素找索引;find找不到返回-1，indx会返回错误*
• s16=len(s) 计算字符串长度
• s17=s.count(‘d’) 字符串出现次数
• name.isalnum() #检查字符串是否含有数字和字符
• name.isalpha() #检查字符串是否只含字符
• name.isdigit() #检查字符串是否只含数字

1.5字符串格式化输出：

• %是占位符
• s字符串
• d表示数字

p1="name:{}, age{}, hobbie{}"
s18=p1.format('morgan',12,'girl')   #{}按照默认位置替换

p2="name{0}, age{1}, hobbie{2},name{0}"
s19=p2.format('morgan',12,'girl')   #{index}按照index替换

p3="name{n}, age{a}, hobbie{h},name{a}"
s20=p3.format(n='morgan',a=21,h='gie')  #{variable}按照variable替换

2.数据类型转换

str—>int int(‘123’)
int—>str str(1)
int—>bool 0—>False;非0（正整数和负整数）—>True
bool—>int
print(bool(”))=False
print(bool(’ ‘))=True

3.列表

按照索引取，取出来的元素与其本身的数据类型一致。

3.2增删改查

3.2.1增加

• append
• insert
• extend #增加最小组成元素
  例子：list.extend([1,2,(3,4),’2321’])
  结果=[1, 2, (3, 4), ‘2321’]
  extend(iterable)
凡是可以for循环的，都是Iterable
凡是可以next()的，都是Iterator

3.2.2删除

3.2.2.1 按索引删除

• pop #只有pop有返回值，返回值为被删除的元素

3.2.2.2 按元素删除

• remove
• clear #清空
• del #删除列表；按照索引删除del s[1]；按照切片删除del s[1:]

3.2.3更改

3.2.3.1按照索引更改

• list[1]=”xx”

3.2.3.2按切片改

>

l = [1,(2,4),2,3,4,5,6,"morgan","xu"]
l[:2]='sdada'
print(l)
['s', 'd', 'a', 'd', 'a', 2, 3, 4, 5, 6, 'morgan', 'xu']

添加步长后，原列表被替代长度内存在元素位置与被更新元素个数要一致

l = [1,(2,4),2,3,4,5,6,"morgan","wusir"]
l[:3:2]='sa'
print(l)

3.2.4.查

3.2.4.1按索引查

3.2.4.2按切片（步长）

3.2.5排序

• sort #正序排序
• sort(reverse=True) #倒序排序
• list.reverse() #反转

3.2.6列表嵌套

l1 = [1,2,'alex',['wusir','taibai',99],6]
l1[2] = l1[2].capitalize()
l1[3][0] = l1[3][0].upper()
l1[3][-1] = str(l1[3][-1]+1)
print(l1)

3.2.7Range

• range数字组成的列表，范围可定制
  for x in range(1,11)
  for i in range(2,100,2)
  for i in range(100,1,-2)

4.元组（只读列表）

• 元组切片后还是元组；
• 可以用for循环；
• tu1 = (1,2,[1,2],4) #元组里面的列表可以更改

5.字典

• 字典键值是唯一，用二分查找实现，最多找7次2**n<=100—>n=7，所以字典查询快。
• 字典键值是唯一的。

5.1字典的增删改查

5.1.1增加

5.1.1.1按键值增加

• dic[‘hobbie’] = ‘oldgirl’无则增加，有则修改。
• dic.setdefault(‘high’)

5.1.2删除

• pop #删除键值对，有返回值
• clear
• del #删除整个字典，按照键值删除
• del #删除不存在容易报错，最好用pop

5.1.3更改

• update #覆盖更新，有则覆盖，无则增加

5.1.4查

• dic.get() #有返回值
• dict.keys() #返回类似列表的容器，可以for循环，没有索引
• dict.values() #返回所有数值
• dict.items() #返回元组

5.2字典和列表嵌套出现问题

列表问题：
在循环一个列表时候，不要改变列表的大小（解决：从列表后面开始循环）

l=['as','af','ss']
for i in range(len(l)):
    if 'a' in l[i]:
        l.pop(i)
print(l)
解决：
l=['as','af','ss']
s=len(l)
for i in range(s-1):
    if 'a' in l[i]:
        l.pop(i)
print(l)

字典问题

dic = {'k1':'v1','k2':'v2','k3':'v3','name':'morgan'}
for k in dic.keys():
    if 'k' in k:
        dic.pop(k)
print(dic)
Error: RuntimeError: dictionary changed size during iteration

解决：
l1 = []
for i in dic:
    if 'k' in i:
        l1.append(i)
print(l1)
for i in l1:
    del dic[i]
print(dic)

5.3fromkeys问题

函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。
如果我们对列表增加了一个元素，比如说append一下，那么所有的列表都会append。如果直接修改值，那么不会有这样的变化。

seq=('name', 'age', 'sex')
dic=dict.fromkeys(seq, [10,2])
dic['name'].append(1)
print(dic)
{'name': [10, 2, 1], 'age': [10, 2, 1], 'sex': [10, 2, 1]}

dic['name]='morgan'
print(dic)
{'name': 'morgan', 'age': [10, 2], 'sex': [10, 2]}

7.前后都是比较运算：

• and>or>not有优先级，不是从左至右计算的。
  print(1>2 and 3<4 or 2>1)

• x or y if x is True, return x

• x and y if x is True, return y
  print(3 or 4)—->3
  print(0 or 4)—->4
  print(-1 or 4)—->-1
  print(3 and 4)—->4

6.数据类型分类

• int, str, bool,tuple(不可变的数据类型，可以作为键值，可哈希)
• dict,list,set(可变的数据类型，不可以作为键值，不可哈希)

7.分别赋值

例子：
a,b = 1,3
a,b = [22,33]

for k,v in dict.items():
print(k,v)