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

概要：

可变和不可变类型
字符串类型
　　按照索引取值
　　切片
　　反向读取
　　长度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不变得情况下，值不可发生改变，但是如果在不可变类型元祖内存储可变类型列表，内部可变类型的值可以改变。

x=10
print(id(x))
x=11
print(id(x))    #id随着值得改变而改变


y=['a','b','c']
print(id(y))
y[0]='A'
print(y)
print(id(y))
结果：     31273608
     　　 ['A', 'b', 'c']
     　　 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)) # 十进制=>十六进制

字符串类型

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

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])

　　　　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.

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

用户登录，强制用户输入数字
age_of_db=30
inp_age=input('>>>: ').strip()#去除空格
if inp_age.isdigit():                 #检验是否为数字
    inp_age=int(inp_age)
    if inp_age > age_of_db:
        print('too big')
    elif inp_age < age_of_db:
        print('too small')
    else:
        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	world'.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())

 列表类型

===================================基本使用===================================
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))