day05-数据类型的使用

一：整形基本使用（int） 

 1 一：整形基本使用（int）
 2  1 int用途:年龄 号码 等级...
 3 
 4  2 定义方式
 5  age=10 age=int(10)
 6  x=int('1111')  int只能将纯数字的字符串转成十进制的整型
 7  print(type(x))
 8 
 9  3 整形常用操作+内置的方法
10 算数运算（+、—、*、/）,比较运算（>,<,>=,<=,!=）
11 
12 二：整形总结
13  1 存一个值or存多个值?
14      只能存一个值
15 
16  2 有序or无序?
17     没有有序无序这么一说
18 
19  3 可变or不可变
20      可变不可变类型总结:
21      可变指的是改变原值,即在原值基础上进行修改
22      可变类型的底层原理:在id不变的情况下,值可以改变
23      不可变类型的底层原理:值改变,id也跟着变
24 int是不可变数据类型
25  age=10
26  print(id(age))
27  age=11
28  print(id(age))
29 
30  长整型Long,只有在python2中才有长整型号
31  复数complex
32  x=1-2j
33  print(x.real)
34  print(x.imag)
35  print(type(x))

example

二：浮点型基本使用（float）

 1 一：浮点型基本使用（float）
 2  1 用途:薪资 身高 体重
 3 
 4  2 定义方式
 5 salary=3.1 salary=float(3.1)
 6 n=float('3.1')
 7 
 8  3 常用操作
 9 算数运算 比较运算
10 
11  二：该类型总结
12  1 存一个值or存多个值
13      只能存一个值
14 
15  2 有序or无序
16     没有有序无序这么一说
17 
18  3 可变or不可变
19  float是不可变类型
20  x=3.1
21  print(id(x))
22  x=3.2
23  print(id(x))

example

三：字符串基本使用（str） 

  1 一：字符串基本使用（str）
  2  1 用途: 描述性质的数据,比如人的名字,单个爱好,地址
  3 
  4  2 定义方式
  5  name='egon' name=str('egon')
  6  x=str(1)
  7  y=str(1.1)
  8  z=str([1,2,3])
  9  n=str({'a':1})
 10  print(type(x))
 11  print(type(y))
 12  print(type(z))
 13  print(type(n))
 14 
 15  3 常用操作+内置的方法
 16 优先掌握的操作(*****)：
 17 1、按索引取值(正向取+反向取) ：只能取
 18  msg='hello world'
 19  print(type(msg[5]))
 20  print(msg[-1])
 21  msg[2]='A'
 22 
 23 2、切片(顾头不顾尾，步长)
 24 msg='hello world'
 25  print(msg[1:5],type(msg[1:5]))
 26  print(msg[6:-1])
 27  print(msg[6:11])
 28  print(msg[6:])
 29  print(msg[6::2])
 30  了解(**)
 31 
 32  print(msg[0:])
 33  print(msg[::-1])
 34  msg='hello world'
 35  print(msg[-3:-6:-1])
 36  print(msg[6:9:-1])
 37 
 38 3、长度len
 39  msg='hello world'
 40  print(len(msg))
 41 
 42 4、成员运算in和not in
 43  print('SB' in  'my name is alex,alex is SB')
 44  print('alex' in  'my name is alex,alex is SB')
 45  print('egon' not in  'my name is alex,alex is SB')  推荐
 46  print(not 'egon' in  'my name is alex,alex is SB')
 47 
 48 
 49 5、移除空白strip
 50  name='  e gon        '
 51  print(name.strip(' '))
 52  print(name.strip())
 53  name='****A*e*gon****'
 54  print(name.strip('*'))
 55 
 56  name='****egon****'
 57  print(name.lstrip('*'))
 58  print(name.rstrip('*'))
 59  pwd=input('>>: ').strip() pwd='123  '
 60  if pwd == '123':
 61      print('login successful')
 62 
 63 
 64  msg='cccabcdefgccccc'
 65        
 66  print(msg.strip('c'))
 67 
 68  print('*-=egon *&^'.strip('-= *&^'))
 69 
 70 6、切分split
 71  msg='egon:18:male:180:160'
 72  l=msg.split(':')
 73  print(l)
 74  print(l[3])
 75 7、循环
 76  msg='hello world'
 77  for x in msg:
 78      print(x)
 79 
 80  需要掌握的操作(****)
 81 1、strip,lstrip,rstrip
 82 2、lower,upper
 83  name='EoN'
 84  print(name.lower())
 85 
 86  name='egonN'
 87  print(name.upper())
 88 
 89 3、startswith,endswith
 90  print('alex is SB'.startswith('alex'))
 91  print('alex is SB'.endswith('B'))
 92 
 93 4、format的三种玩法
 94  print('my name is %s my age is %s' %('egon',18))
 95  print('my name is {name} my age is {age}'.format(age=18,name='egon'))  可以打破位置的限制,但仍能指名道姓地为指定的参数传值
 96 
 97  print('my name is {} my age is {}'.format('egon',18))
 98  print('my name is {0} my age is {1} {1} {1} {1}'.format('egon',18))
 99 
100 5、split,rsplit
101  info='egon:18:male'
102  print(info.split(':',1))
103 
104  print(info.split(':',1)) ['egon','18:male']
105  print(info.rsplit(':',1)) ['egon:18','male']
106 
107 6、join:只能将元素全为字符串的列表拼成一个大的字符串
108  info='egon:18:male'
109  l=info.split(':')
110  print(l)
111  new_info='-'.join(l)
112  print(new_info)
113 
114  num=['a','b','c']
115  ':'.join(num) 'a'+':'+'b'+':'+'c'
116 
117  num=[1,2,'c']
118  ':'.join(num) 1+':'+2+':'+'c'
119 
120 7、replace
121  msg='my name is wupeiqi,wupeiqi is SB'
122  print(msg.replace('wupeiqi','Pig',1))
123  print(msg)
124 
125 8、isdigit
126  print('111.1'.isdigit())
127  print('1111'.isdigit())
128 
129  AGE=73
130  age=input('>>: ').strip() age='asdfasdf'
131  if age.isdigit():
132      age=int(age)
133      if age > AGE:
134          print('too big')
135      elif age < AGE:
136          print('too small')
137      else:
138          print('you got it')
139  else:
140      print('必须输入数字啊傻叉')
141 
142 1、find,rfind,index,rindex,count
143 msg='my name is alex,alex is hahaha'
144  print(msg.find('alex'))
145  print(msg.find('SB')) 找不到会返回-1
146 
147  print(msg.index('alex'))
148  print(msg.index('SB'))  找不到index会报错
149 
150  print(msg.find('alex',0,3))
151 
152  print(msg.count('alex'))
153  print(msg.count('alex',0,15))
154 
155 2、center,ljust,rjust,zfill
156  print('info egon'.center(50,'-'))
157  print('info egon'.ljust(50,'-'))
158  print('info egon'.rjust(50,'-'))
159  print('info egon'.zfill(50))
160 
161 3、expandtabs
162  print('a\tb\tc'.expandtabs(1))
163 
164 4、captalize,swapcase,title
165  print('my name is egon'.capitalize())
166  print('my Name Is egon'.swapcase())
167  print('my name is egon'.title())
168 
169 5、is数字系列
170 num1=b'4' bytes
171 num2=u'4' unicode,python3中无需加u就是unicode
172 num3='壹' 中文数字
173 num4='Ⅳ' 罗马数字
174 
175 isdigit():bytes,unicode
176  print(num1.isdigit())
177  print(num2.isdigit())
178  print(num3.isdigit())
179  print(num4.isdigit())
180 
181 isdecimal():unicode
182  print(num2.isdecimal())
183  print(num3.isdecimal())
184  print(num4.isdecimal())
185 
186 isnumberic;unicode,中文,罗马
187  print(num2.isnumeric())
188  print(num3.isnumeric())
189  print(num4.isnumeric())
190 
191 6、is其他
192  print('abasdf123123'.isalnum())
193  print('asdfasdf'.isalpha())
194  print('egon'.islower())
195  print('ABC'.isupper())
196 
197  print('     '.isspace())
198  print('My Name Is Egon'.istitle())
199 
200 
201  二：该类型总结
202  1 存一个值or存多个值
203      只能存一个值
204 
205  2 有序or无序
206  有序
207 
208  3 可变or不可变
209  不可变
210 
211 name='egon'
212 print(id(name))
213 name='alex'
214 print(id(name))
215 作用：多个装备，多个爱好，多门课程，多个女朋友等

example

 四、列表基本使用（list）

  1 定义：[]内可以有多个任意类型的值，逗号分隔
  2  my_girl_friends=['alex','wupeiqi','yuanhao',4,5] 本质my_girl_friends=list([...])
  3 
  4  l=list('hello')  list内只能跟能够被for循环遍历的数据类型
  5  print(l)
  6  l=list({'a':1,'b':2})
  7  print(l)
  8 
  9 优先掌握的操作：
 10 1、按索引存取值(正向存取+反向存取)：即可存也可以取
 11  names=['alex','wxx','lxx','egon']
 12  names[0]='ALEX'
 13 
 14  print(names)
 15 2、切片(顾头不顾尾，步长)
 16  names=['alex','wxx','lxx','egon']
 17  print(names[0:3])
 18 
 19 3、长度
 20  names=['alex','wxx','lxx','egon']
 21  print(len(names))
 22 
 23 4、成员运算in和not in
 24  names=['alex','wxx','lxx','egon',4]
 25  print(4 in names)
 26 
 27 
 28 5、追加
 29  names=['alex','wxx','lxx','egon']
 30  names.append('cxx1')
 31  names.append('cxx2')
 32  names.append('cxx3')
 33  print(names)
 34 
 35 6、删除
 36  names=['alex','wxx','lxx','egon']
 37  del names[2]
 38 
 39  print(names)
 40 
 41 7、循环
 42  names=['alex','wxx','lxx','egon']
 43  for name in names:
 44      print(name)
 45 
 46  需要掌握的操作(****)
 47  names=['alex','wxx','lxx','egon',4,3.1]
 48  names.insert(1,'SB')
 49  print(names)
 50 
 51  names=['alex','wxx','lxx','egon',4,3.1]
 52  res=names.remove('wxx')   单纯的删掉,是按照元素的值去删除，没有返回值
 53  print(res)
 54  print(names)
 55 
 56 
 57  names=['alex','wxx','lxx','egon',4,3.1]
 58  res=names.pop(1) 拿走一个值,是按照索引去删除,有返回值
 59  print(names)
 60  print(res)
 61 
 62  names=['alex','wxx','lxx','egon',4,3.1]
 63  print(names.pop())
 64  print(names.pop())
 65 
 66 names=['alex','wxx','lxx','lxx','egon',4,3.1]
 67  print(names.count('lxx'))
 68 
 69  print(names.index('lxx'))
 70 
 71  names.clear()
 72  print(names)
 73 
 74  x=names.copy()
 75  print(x)
 76 
 77  names.extend([1,2,3])
 78  print(names)
 79 
 80  names.reverse()
 81  print(names)
 82 
 83  names=[1,10,-3,11]
 84  names.sort(reverse=True)
 85  print(names)
 86 
 87 
 88 二：该类型总结
 89  1 存一个值or存多个值
 90      可以存多个值，值都可以是任意数据类型
 91 
 92  2 有序or无序
 93  有序
 94  3 可变or不可变
 95  可变
 96 
 97  l=['a','b']
 98  print(id(l))
 99  l[0]='A'
100  print(id(l))

example

 五、元组基本使用（tuple）

 1 一：基本使用
 2  1 用途：元组是不可变的列表，能存多个值，但多个值只有取的需求，而没有改的需求，那么用元组合最合理
 3 
 4  2 定义方式:在()内用逗号分割开，可以存放任意类型的值
 5  names=('alex','egon','wxx') names=tuple(('alex','egon','wxx'))
 6  print(type(names))
 7  强调: 当元组内只有一个元素时，务必记住加一个逗号
 8  x=('egon',)
 9  print(type(x))
10 
11  3 常用操作+内置的方法
12  1、按索引取值(正向取+反向取)：只能取
13  names=('alex','egon','wxx')
14  names[0]='sb'
15 
16 
17  2、切片(顾头不顾尾，步长)
18  names=('alex','egon','wxx','lxx','cxxx')
19  print(names[1:3]
20  )
21 
22  3、长度
23  names=('alex','egon','wxx','lxx','cxxx')
24  print(len(names))
25  4、成员运算in和not in
26  names=('alex','egon','wxx','lxx','cxxx')
27  print('alex' in names)
28 
29  5、循环
30  names=('alex','egon','wxx','lxx','cxxx')
31  for item in names:
32      print(item)
33 
34 
35  二：该类型总结
36  1 存一个值or存多个值
37      可以存多个值，值都可以是任意数据类型
38 
39  2 有序or无序
40  有序
41  3 可变or不可变
42  不可变
43 
44  names=('alex','egon','wxx','lxx','cxxx','lxx')
45  del names[0]
46  names[0]='sb'
47  print(names.count('lxx'))
48  print(names.index('wxx',0,3))
49 
50  names=('alex','egon','wxx','lxx','cxxx','lxx')
51  names=1
52 
53  l=[1,243,3]
54  l=3333
55  l=['a','b','c']
56  print(id(l[0]))
57  l[0]='A'
58  print(id(l[0]))
59 
60  names=('a','b','c')
61 
62  列表可变的底层原理：
63  指的是索引所对应的值的内存地址是可以改变的
64 
65  元组不可变的底层原理：
66  指的是索引所对应的值的内存地址是不可以改变的
67  或者反过来说，只要索引对应值的内存地址没有改变，那么元组始终是没有改变的
68 
69 t1 = (['a', 'b', 'c'], 'wc', 'office')
70 
71 print(id(t1[0]))
72 print(id(t1[1]))
73 print(id(t1[2]))
74 
75 t1[0][0] = 'AAAA'
76 print(t1)
77 
78 print(id(t1[0]))

example

六、字典基本使用（dict）

  1 一：基本使用
  2  1 用途：用来存多个值，但每一个值都有一个key与之对应，key对值有描述性的功能
  3         当存储多个值表示的不同的状态时，
  4 
  5  2 定义方式:{}内用逗号分隔开多个元素，每一个元素都是key：value的形式
  6 value可以是任意数据类型，但是key必须为不可变类型，key通常应该是字符串类型，
  7  d={'x':1,'y':2} d=dict({'x':1,'y':2})
  8  d=dict(a=1,b=2,c=3)
  9  print(d)
 10 
 11 
 12  dic={1:'a',0:'b',1.1:'c',(1,2,3):'d'}
 13  print(dic[1])
 14  print(dic[0])
 15  print(dic[1.1])
 16  print(dic[(1,2,3)])
 17  dic={[1,2,3]:'a'}
 18  dic={{'x':1}:'a'}
 19 
 20 
 21  3 常用操作+内置的方法
 22 优先掌握的操作：
 23 1、按key存取值：可存可取
 24  d={'x':1,'y':2}
 25  d['x']=100
 26  print(d)
 27  d['z']=3
 28  print(d)
 29 
 30  l=['a','b']
 31  l[2]='c'
 32 
 33 2、长度len
 34  d={'x':1,'y':2}
 35  print(len(d))
 36 3、成员运算in和not in
 37  d={'x':1,'y':2}
 38  print('x' in d)
 39 
 40 4、删除
 41 d={'x':1,'y':2}
 42  del d['x']
 43  print(d)
 44  res=d.pop('y')
 45  print(d)
 46  print(res)
 47 
 48  res=d.popitem()
 49  print(d)
 50  print(res)
 51 
 52  d={'a':1,'b':2,'c':3,'d':4}
 53  for k in d:
 54      print(k)
 55 
 56  l=[1,2,3]
 57  del l[1]
 58  print(l)
 59 
 60 5、键keys()，值values()，键值对items()
 61 msg_dic={
 62 'apple':10,
 63 'tesla':100000,
 64 'mac':3000,
 65 'lenovo':30000,
 66 'chicken':10,
 67 }
 68  names=[]
 69  for k in msg_dic:
 70      names.append(k)
 71  print(names)
 72  values=[]
 73  for k in msg_dic:
 74      values.append(msg_dic[k])
 75  print(values)
 76 
 77  keys=msg_dic.keys()
 78  print(keys)
 79  for k in keys:
 80      print(k)=
 81  l=list(keys)
 82  print(l)
 83 
 84  vals=msg_dic.values()
 85  print(vals)
 86  print(list(vals))
 87 
 88  print(msg_dic.items())
 89  print(list(msg_dic.items()))
 90 6、循环
 91 msg_dic={
 92 'apple':10,
 93 'tesla':100000,
 94 'mac':3000,
 95 'lenovo':30000,
 96 'chicken':10,
 97 }
 98  只取key
 99  for k in msg_dic:
100      print(k,msg_dic[k])
101 
102  for k in msg_dic.keys():
103      print(k,msg_dic[k])
104 
105  只取value
106  for v in msg_dic.values():
107      print(v)
108 
109 取key和value
110  for k,v in msg_dic.items(): k,v=('apple', 10)
111      print(k,v)
112 
113  需要掌握的内置方法（****）
114  d={'x':1,'y':2,'z':3}
115  v=d.get('xxxx')
116  print(v)
117  print(d['xxxxxxx'])
118 
119  d={'x':1,'y':2,'z':3}
120  d1={'a':1,'x':1111111}
121  d.update(d1)
122  print(d)
123 
124  l=['name','age','sex']
125  d={}
126  for k in l:
127      d[k]=None
128  d=dict.fromkeys(l,None)
129  print(d)
130 
131 
132  info.setdefault
133 info={'name':'egon','age':18,'sex':'male'}
134 
135  如果字典中有setdefault指定的key，那么不改该key对应的值，返回原的value
136  res=info.setdefault('name','EGON_NB')
137  print(info)
138  print(res)
139 
140  如果字典中没有setdefault指定的key，那么增加一个key:value,返回新的value
141  info.setdefault('height',1.80)
142  print(info)
143 
144  info={'age':18,'sex':'male'}
145  v=info.setdefault('name','浩哥')
146  print(v)
147 
148 
149 
150 
151 s='hello alex alex say hello sb sb'
152 l=s.split()
153  print(l)
154 d={}
155  for word in l: word=  'hello'
156      if word not in d:
157          d[word]=1 {'hello':2, 'alex':2,'say':1}
158      else:
159          d[word]+=1
160  print(d)
161 
162 s='hello alex alex say hello sb sb'
163 l=s.split()
164 print(l)
165 d={}
166 
167  d={'hello':2,'alex':2}
168 for word in l: word='alex'
169      d[word]=l.count(word) d['alex']=2
170     d.setdefault(word,l.count(word))
171 
172 print(d)
173 
174  二：该类型总结
175  1 存一个值or存多个值
176      可以存多个值，值都可以是任意类型，而key必须是不可变类型，通常应该是不可变类型中字符串类型
177 
178  2 有序or无序
179  无序
180 
181  3 可变or不可变
182 
183 d={'x':1,'y':2}
184  print(id(d))
185  d['x']=1111
186  print(id(d))

example

七、集合基本使用（set）

  1 一：基本使用
  2  1 用途: 关系运算、去重
  3 
  4  2 定义方式:{}内用逗号分隔开多个元素，每一个元素都必须是不可变（即可hash）类型
  5 强调：
  6 2.1 集合内元素都必须是不可变（即可hash）类型
  7 2.2 集合内的元素无序
  8 2.3 集合内的元素不能重复
  9 
 10  s={1,2,'a'} s=set({1,2,'a'})
 11  print(type(s))
 12 
 13  s={1.1,1,'aa',(1,2,3),{'a':1}}
 14 
 15  s={1,'a','hello',(1,2,3),4}
 16  for item in s:
 17      print(item)
 18 
 19  s={1,1,1,1,1,1,1,1,1,'a','b','a'}
 20  s={(1,2,3),(1,2,3),'a','b','a'}
 21  print(s)
 22 
 23 s=set('hello')
 24 print(s)
 25 
 26  单纯的用集合去重，需要注意的问题是
 27 1、去重的目标所包含的值必须都为不可变类型
 28 2、去重的结果会打乱原来的顺序
 29  names=['asb','asb','asb','wsb','wsb','isetan_nb',[1,2,3]]
 30  s=set(names)
 31 
 32  names=list(s)
 33  print(names)
 34 
 35 
 36  3 常用操作+内置的方法
 37 优先掌握的操作：
 38 1、长度len
 39  pythoners={'王大炮','李二丫','陈独秀','艾里克斯','wxx','欧德博爱'}
 40  print(len(pythoners))
 41 
 42 2、成员运算in和not in
 43  print('李二丫' in pythoners)
 44 
 45 
 46 pythoners={'王大炮','李二丫','陈独秀','艾里克斯','wxx','欧德博爱'}
 47 linuxers={'陈独秀','wxx','isetan','张全蛋'}
 48 3、|并集
 49  print(pythoners | linuxers)
 50  print(pythoners.union(linuxers))
 51 
 52 4、&交集
 53  print(pythoners & linuxers)
 54  print(pythoners.intersection(linuxers))
 55  print(linuxers & pythoners)
 56  5、-差集
 57  print(pythoners - linuxers)
 58  print(pythoners.difference(linuxers))
 59  print(linuxers - pythoners)
 60  print(linuxers.difference(pythoners))
 61 6、^对称差集
 62 pythoners={'王大炮','李二丫','陈独秀','艾里克斯','wxx','欧德博爱'}
 63 linuxers={'wxx','isetan','张全蛋'}
 64  print(pythoners ^ linuxers)
 65  print(pythoners.symmetric_difference(linuxers))
 66 
 67  print(linuxers ^ pythoners)
 68 7、==
 69  s1={1,2,3}
 70  s2={1,2,3}
 71  print(s1 == s2)
 72 
 73 8、父集(包含关系)：>,>=
 74  s1={1,2,3,4,5}
 75  s2={1,2,3}
 76  print(s1 > s2)  s1包含s2
 77  print(s1.issuperset(s2))
 78  print(s2.issubset(s1))
 79 
 80  s3={1,2,10}
 81  print(s1 > s3)
 82 
 83  s1={1,2,3,4,5}
 84  s2={1,2,3,4,5}
 85  print(s1 >= s2)
 86 
 87 9、子集(被包含的关系)：<,<=
 88 
 89 s1={1,2,3,4,5}
 90 s1.add(6)
 91  print(s1)
 92 
 93  s1.update({4,7,8,9})
 94  print(s1)
 95 
 96  res=s1.pop()
 97  print(res)
 98 
 99  res=s1.remove(4)
100  print(res)
101  print(s1)
102 
103 s1={1,2,3,4,5}
104 s2={2,3,7,8}
105  s1=s1 - s2
106  print(s1)
107  s1.difference_update(s2)  s1=s1 - s2
108  print(s1)
109 
110  s1={1,2,3,4,5}
111  s1.pop()
112  s1.remove(7)
113  s1.discard(7)  即便要删除的元素不存在也不会报错
114 
115 s1={1,2,3,4,5}
116 s2={6,7}
117 print(s1.isdisjoint(s2))无交集部分
118 
119 
120 
121 
122  二：该类型总结
123  1 存一个值or存多个值
124      可以存多个值，值都必须为不可变类型
125 
126  2 有序or无序
127  无序
128 
129  3 可变or不可变
130  set集合是可变类型
131  s={1,2,3}
132  print(id(s))
133  s.add(4)
134  print(s)
135  print(id(s))
136 
137 
138 
139 =====================集合的去重==========================
140  单纯的用集合去重，需要注意的问题是
141 1、去重的目标所包含的值必须都为不可变类型
142 2、去重的结果会打乱原来的顺序
143  names=['asb','asb','asb','wsb','wsb','isetan_nb',[1,2,3]]
144  s=set(names)
145 
146  names=list(s)
147  print(names)
148 
149 stu_info=[
150     {'name':'isetan','age':18,'sex':'male'},
151     {'name':'isetan','age':18,'sex':'male'},
152     {'name':'isetan','age':18,'sex':'male'},
153     {'name':'axxxx','age':73,'sex':'male'},
154     {'name':'oldboy','age':84,'sex':'female'},
155 ]
156 
157 new_info=[]
158 for info in stu_info:
159     if info not in new_info:
160         new_info.append(info)
161 
162  print(new_info)

example

 

补充：

队列：先进先出
l=[]
入队
l.append('111')
l.append('222')
l.append('333')
出队
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))
堆栈：先进后出
l=[]
入栈
l.append('111')
l.append('222')
l.append('333'))
出栈

print(l.pop())
print(l.pop())
print(l.pop())

 

转载于:https://www.cnblogs.com/wcl0517/p/9111596.html