数字,字符串,列表及其内置方法

概要:

可变和不可变类型
字符串类型
  按照索引取值
  切片
  反向读取
  长度len()
  成员运算in和not in
  移除字符串两边字符strip
  切分split
  循环for
   需要掌握的操作:
  strip,lstrip,rstrip
  lower,upper
  startwith,endwith
  format:对应关系
  split,rsplit
  join
  replace
  isdigit
列表类型
  按照索引取值
  切片
  长度len()
  成员运算in和not
  追加
  删除
  循环for
   需要掌握的操作:
  计量列表中某个元素的个数
  向列表追加列表的两种方式
  取元素的索引
  插入元素
  反转
  对元素排序
  队列和堆栈:li.pop()





































可变类型:
值变了,但是id没有变,证明没有生成新的值而是在改变原值,原值是可变类型,不可hash。在id不变得情况下,值可以改变
不可变类型:值变了,id也跟着变,证明是生成了新的值而不是在改变原值,原值是不可变,可hash。
      在id不变得情况下,值不可发生改变,但是如果在不可变类型元祖内存储可变类型列表,内部可变类型的值可以改变。

 1 x=10
 2 print(id(x))
 3 x=11
 4 print(id(x))    #id随着值得改变而改变
 5 
 6 
 7 y=['a','b','c']
 8 print(id(y))
 9 y[0]='A'
10 print(y)
11 print(id(y))
12 结果:     31273608
13         ['A', 'b', 'c']
14         31273608  #证明列表类型属于可变类型

 

# 数字类型为不可变类型
a = 20
b = a
a = 21
print(a)#21
print(b)#20

# 列表为可变类型
a = [1,2,3]
b = a
a.append(4)
print(b)#[1,2,3,4]

# 字符串为不可变类型
a = "abc"
b = a
a = "ABC"
print(a)#ABC
print(b)#abc

x = [1,2]
print(id(x))#x = [1,2],31204616
y = x
# x[1] = 3 #在原列表上改
x = [1,3] #重新赋值
print(x)#[1, 3]
print(y)#[1, 2]
print(id(x))#x = [1,3],31204424
print(id(y))#y = [1,2],31204616
 

 

数字类型

一: 整型int
  ===========================基本使用===============================
  1、用途: 记录年龄\等级\各种号码

  2、定义方式:
    age=18 # age=int(18)
    x=int('123') #只能将纯数字的字符串转换成整型
    print(type(x))
    print(int(3.7))#取整,非四舍五入

  3、常用操作+内置的方法
    赋值\比较\算术
  ===============================该类型总结===============================
  存一个值
  不可变(1、可变:值变,id不变。可变==不可hash 2、不可变:值变,id就变。不可变==可hash)
  print(hash(10))

二:浮点型float
  ==============================基本使用==================================
  1、用途: 记录身高\体重\薪资

  2、定义方式
  salary=1.3 #salary=float(1.3)
  x=float('3.1')
  print(x,type(x))

了解:
复数
x=1-2j
print(x,type(x))
print(x.real)#1,实数
print(x.imag)#2,虚数

长整型
Python2 的方法,Python3 取消了

其他进制=>十进制
十进制: 0-9
= 1*10^1 + 1*10^0

二进制: 0 1
= 1*2^1 + 1*2^0

八进制: 0-7
= 1*8^1+1*8^0

十六进制:0-9 A-F
= 1*16^1+1*16^0

十进制=>其他进制
print(bin(13)) # 十进制=>二进制
print(oct(13)) # 十进制z=>八进制
print(hex(13)) # 十进制=>十六进制
View Code

字符串类型

     ==============================基本使用=================================

1、用途:记录描述性质的特征,比如名字\地址\性别

2、定义方式:在单引号\双引号\三引号内包含的一串字符
  msg='aaa"bbb"' #msg=str(...)
  可以将任意类型转换成字符串
    str(1)
    str(1.3)
    x=str([1,2,3])
    print(x,type(x))

3、常用操作+内置的方法
  优先掌握的操作(*****)
1、按索引取值(正向取+反向取) :只能取
    ---------------------------------------------------------------

    msg='hello world'
    print(msg[0])
    print(msg[5])
    print(msg[len(msg)-1])
    print(msg[-1])
    msg[0]='H'      #报错,说明不可变

2、切片(顾头不顾尾,步长): 想要从一个大字符串中切出一个小字符串
    ---------------------------------------------------------------
    msg='hello world'
    print(msg[0:5])
    print(msg)
    print(msg[0:5:2]) #0 2 4,0-5的范围内,步长为2

了解
msg='hello world'
print(msg[-1:-5:1])  #反向读取,步长为1,读取不到
print(msg[-1:-5:-1]) #d l r o,步长为-1,可以读取
print(msg[0:5:1])
View Code
    print(msg[-1::-1])  #掌握,反向读取,读到头,步长为-1;
               步长不写默认为1,当反向读取时要注意步长的符号


3、长度len
    ------------------------------------------------------------------
    msg='你好啊a'     #中文字符占一个长度
    print(len(msg))   # 4

4、成员运算in和not in
    -----------------------------------------------------------------
    msg='yangyuanhu 老师是一个非常虎的老师
    print('yangyuanhu' in msg)
    print('虎' not in msg)

5、移除字符串左右两边的字符strip:默认去空格
    -----------------------------------------------------------------
    pwd=' 1 23 '
    res=pwd.strip(' ')
    print(res)      #'1 23',碰到第一个不为空格的内容停止去除,所以1和2之间的空格不能去除
    -------------------------------------------------------------------------
    pwd=input('>>: ').strip() #pwd='123',去除用户手误输入的空格;
    if pwd == '123':
    print('密码输入正确')
     ---------------------------------------------------------------------------------
    pwd='******12*3****'
    print(pwd.strip('*'))#'12*3'
     ---------------------------------------------------------------------------------
    pwd='****/&^**123**^*/*&'
    print(pwd.strip('*/&^'))#123
    print(pwd.strip('*/&')) #^**123**^
     --------------------------------------------------------------------------------
6、切分split:针对有规律字符串按照某个字符切成列表
    -----------------------------------------------------------------------
    info='yyhdsb|18|female'
    li=info.split('|',1) # 以|切分,切分一次
    print(li)       # ['yyhdsb','18|female']
     ------------------------------------------------------------------------------
7、循环
    msg='hello'
    for item in msg:
  print(item)      # h e l l o


================================该类型总结================================
存一个值

有序

不可变(1、可变:值变,id不变。可变==不可hash 2、不可变:值变,id就变。不可变==可hash)
    s1='hello'
    print(id(s1)) #40874536
    s1='world'
    print(id(s1)) #41644360,不可变类型
------------------------------------------------------------------------------------
需要掌握的操作(****)
1、strip,lstrip,rstrip
    print('****egon***'.strip('*'))   #左右去除*
    print('****egon***'.lstrip('*'))  #左去除*
    print('****egon***'.rstrip('*'))  #右去除*
2、lower,upper
    print('AAAbbbb'.lower())       #全小写
    print('AAAbbbb'.upper())       #全大写

3、startswith,endswith
    print('alex is sb'.startswith('alex')) #判断是否以Alex开头
    print('alex is sb'.endswith('sb'))   #判断是否以sb结尾

4、format的三种玩法
    print('my name is %s my age is %s' %('egon',18))
    print('my name is %s my age is %s' %(18,'egon')) #只有顺序对应关系

    print('my name is {name} my age is {age} '.format(age=18,name='egon'))
了解
print('my name is {} my age is {} '.format(18,'egon'))
    #默认按照顺序对应
print('my name is {0} my age is {1} '.format(18,'egon'))
    #以索引进行对应
print('my name is {1} my age is {0} '.format(18,'egon'))
    #my name is 18,my age is egon.
View Code
5、split,rsplit
    msg='a:b:c:d:e'
    print(msg.split(':',1))  #以:进行分割,从左向右分割一次,分割后组成列表  ['a', 'b:c:d:e']
    print(msg.rsplit(':',1)) #以:进行分割,从右向左分割一次,分割后组成列表   ['a:b:c:d', 'e']
6、join
    list1=['a','b','c','d']
    msg1=':'.join(list1)    # 将list1的元素用:分割开
    print(msg1)         # a:b:c:d 转换成了字符串类型
----------------------------------------------------------------------------------
    info='egon:123:male'
    list1=info.split(':')   # ['egon','123','male']
    print(list1)        
    print(':'.join(list1))   # egon:123:male

7、replace
    msg='alex is alex alex is hahahaha'
    print(msg.replace('alex','SB',1))  # (old,new,count):要替换的旧元素,新元素,要替换的个数

8、isdigit
    print('123'.isdigit()) # 只能判断纯数字的字符串,True
    print('12.3'.isdigit())# False,'12.3'在字符串中,无法识别小数
-----------------------------------------------------------------------
    
num1=b'4' #bytes
     num2=u'4' #unicode,python3中无需加u就是unicode
     print(num1.isdigit())   #True
     print(num2.isdigit())  #True
 
 1 用户登录,强制用户输入数字
 2 age_of_db=30
 3 inp_age=input('>>>: ').strip()#去除空格
 4 if inp_age.isdigit():                 #检验是否为数字
 5     inp_age=int(inp_age)
 6     if inp_age > age_of_db:
 7         print('too big')
 8     elif inp_age < age_of_db:
 9         print('too small')
10     else:
11         print('you got it')
了解的操作(**)
1、find,rfind,index,rindex,count
  msg='hello worldaa'
  print(msg.index('wo'))
  print(msg.index('wo',0,3))
  print(msg.find('wo',0,3))
  print(msg.find('xxxxxxx'))
  print(msg.index('xxxxxxx'))
  print(msg.count('l'))

2、center,ljust,rjust,zfill
  name=input('>>: ').strip()
  print('egon'.center(50,'='))
  print(('%s' %name).center(50,'-'))

  print('egon'.ljust(50,'='))
  print('egon'.rjust(50,'='))
  print('egon'.zfill(50))

3、expandtabs
  print('hello\tworld'.expandtabs(5))

4、captalize,swapcase,title
  print('hello world'.capitalize())
  print('Hello world'.swapcase())
  print('Hello world'.title())

5、is数字系列
  num1=b'4' #bytes
  num2=u'4' #unicode,python3中无需加u就是unicode
  num3='' #中文数字
  num4='' #罗马数字

  isdigit: bytes,str
  print(num1.isdigit())
  print(num2.isdigit())
  print(num3.isdigit())
  print(num4.isdigit())

  isdecimal:str
  print(num2.isdecimal())
  print(num3.isdecimal())
  print(num4.isdecimal())

  isnumberic:str,中文\罗马    #主要用于银行业务
  print(num2.isnumeric())
  print(num3.isnumeric())
  print(num4.isnumeric())

6、is其他
  print('aaasdfaA'.isalpha()) # 纯字母组成的字符串
  print('aaasdfaA123'.isalnum()) # 字母或数字组成
  print('aaasdfaA'.isalnum()) # 字母或数字组成
  print('123'.isalnum())

  print('    '.isspace())
  print('    12'.isspace())
View Code

 列表类型

===================================基本使用===================================
1、用途:记录多个值,比如人的多个爱好

2、定义方式: 在[]内用逗号分隔开多个任意类型的值
  li=[1,2,3] # li=list([1,2,3])
------------------------------------------------------------------------------------
  x=list('hello')      #将hello以字符的形式加入列表
  x=list({'a':1,'b':2,'c':3})    #将字典的key以列表的形式打印出来

3、常用操作+内置的方法
  优先掌握的操作:
1、按索引存取值(正向存取+反向存取):既可存也可以取
    li=['a','b','c','d']
    print(li[-1])  #取倒数第一个值
    li[-1]='D'    #将倒数第一个值换为D
----------------------------------------------------------------------------------------
    li[4]='e'     #报错,超出列表范围
    del li[0]     #删除索引为0的值
    print(li)
----------------------------------------------------------------------------------------
2、切片(顾头不顾尾,步长)
    li=['a','b','c','d']
    print(li[0:3])
-----------------------------------------------------------------------------------------
3、长度
    print(len(li))
4、成员运算in和not in
    users=['egon','lxx','yxx','cxxx',[1,2,3]]
    print('lxx' in users)
    print([1,2,3] in users)
    print(1 in users)    #False,[1,2,3]是一个整体,不能拆分
----------------------------------------------------------------------------------------
5、追加
    li=['a','b','c','d']
    print(id(li))
    li.append('e')      #在最后追加,e
    li.append([1,2,3])   #在最后追加一个列表[1,2,3],列表是一个整体
    print(li,id(li))     #列表是可变类型,id不会改变
---------------------------------------------------------------------------------------
6、删除
    li=['a','b','c','d']
  按照元素值去单纯地删除某个元素
    del li[1]        #常规的删除元素方法。
    res=li.remove('c')   #直接移除c,不会保留移除的元素,没有返回值
    print(li)
    print(res)        # None,没有返回值
  按照元素的索引去删除某个元素并且拿到该元素作为返回值
   res=li.pop(1)
    print(li)
    print(res)        #b

7、循环
    li=['a','b','c','d']
    for item in li:
    print(item)
===============================该类型总结=================================
存多个值

有序

可变(1、可变:值变,id不变。可变==不可hash 2、不可变:值变,id就变。不可变==可hash)
print(hash([1,2,3]))


需要掌握的操作:
li=['a','b','c','d','c','e']
  print(li.count('c'))    #计量c的个数
  li.extend([1,2,3])     #将列表[1,2,3]的元素单个的加入原列表 ['a', 'b', 'c', 'd', 'c', 'e', 1, 2, 3]
  li.append([1,2,3])     #将列表整个加入原列表 ['a', 'b', 'c', 'd', 'c', 'e', 1, 2, 3, [1, 2, 3]]
  print(li)

  print(li.index('b'))    #取索引
  print(li.index('d',0,4))  #('d',0,4)在索引0-4之间寻找d的索引,顾首不顾尾

  li.insert(1,'egon')     #在索引1之前插入egon。
  print(li)

  li=[3,1,9,11]
  li.reverse()         #直接反转,不对数据进行排序
  print(li)

  li.sort(reverse=True)    #对数据进行从大到小排序
   li.sort(reverse=False)   #对数据进行从小到大排序
示例:
队列: 先进先出    q=[]
# 入队
    q.append('first')
    q.append('second')
    q.append('third')
    print(q)
# 出队
    print(q.pop(0))
    print(q.pop(0))
    print(q.pop(0))

堆栈: 先进后出 q=[] # 入栈 q.append('first') q.append('second') q.append('third') # 出栈 print(q.pop(-1)) print(q.pop(-1)) print(q.pop(-1))

 


posted @ 2018-09-17 15:41  ChuckXue  阅读(269)  评论(0编辑  收藏  举报