基本类型及其内置方法（上）

8-2

**程序 = 数据（变量+文件）+功能（与用户交互+运算符=+流程控制）**

可变与不可变类型

# 如果值改变，但是内存地址不变，证明就是在改变原值，即原值可变
# 如果值改变，但是内存地址也变了，证明不是在改变原值，而是产生了新的值，即原值不可变

# x = 10
# print(id(x))
# x = 11
# print(id(x))

# l = [111, 222, 333]
# print(id(l))
# l[0] = 666
# print(id(l))

数据类型

**int**
# ======================================int基本使用=====================================
# 1、用途

# 2、定义方式
age = 18  本质# age = int(18)
# print(type(age))

# int数据类型转换
# res = int("    18    ")
# print(res,type(res))

# 3、常用操作+内置的方法
# 算数运算+比较运算

# ======================================该类型总结=============================
# 存一个值
# 不可变

**float**
# ======================================float基本使用===================================
# 1、用途

# 2、定义方式
salary = 3.33  # salary = float(3.33)

# float数据类型转换
# res = float("    1.8    ")
# print(res,type(res))

# 3、常用操作+内置的方法
# 算数运算+比较运算

# ======================================该类型总结====================================
# 存一个值
# 不可变

# **注意**：名字+括号的意思就是调用某个功能，
比如# print(...)调用打印功能
# int(...)调用创建整型数据的功能
# float(...)调用创建浮点型数据的功能

# **注意**：名字+括号的意思就是调用某个功能，
比如# print(...)调用打印功能
# int(...)调用创建整型数据的功能
# float(...)调用创建浮点型数据的功能

# 1、数据类型转换
# 1.1 int可以将由纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错
>>> s = '123'
>>> res = int(s)
>>> res,type(res)
(123, <class 'int'>)

【>>> int('12.3') # **错误演示**：字符串内包含了非整数符号.
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '12.3'】

# 1.2 进制转换
# 十进制转其他进制
>>> bin(3)
'0b11'
>>> oct(9)
'0o11'
>>> hex(17)
'0x11'
# 其他进制转十进制
>>> int('0b11',2)
3
>>> int('0o11',8)
9
>>> int('0x11',16)
17

# 1.3 float同样可以用来做数据类型的转换
>>> s = '12.3'
>>> res=float(s)
>>> res,type(res)
(12.3, <class 'float'>)

**str**
# ======================================str基本使用=====================================
# 1、用途

# 2、定义方式
# 定义：在单引号\双引号\三引号内包含一串字符   (三引号用于引用多行字符）（外双内单）
name1 = 'jason'  # 本质:name = str('任意形式内容')
name = "egon"  # name = str("egon")

# **str数据类型转换：可以把任意类型都转换成字符串类型**

# res = str([1,2,3])
# print(res,type(res))  # "[1,2,3]"

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

#      0123
# msg = 'hello world'
# print(msg[4])
# print(msg[5])

# (2)、切片(顾头不顾尾，步长)：从一个大字符串中拷贝出一个子字符串
# msg = 'hello world'
#
# # res = msg[1:5:2]  # 1 3
# # res = msg[1:5]  # 1234
# # res = msg[1:]  #
# # res = msg[:]  #
# # res = msg[-1:-4:-1]  # -1 -2 -3
# # res = msg[-1::-1]  # -1 -2 -3
# res = msg[::-1]  # 将字符串颠倒
#
# print(res)
# print(msg)

# (3)、长度len（获取字符串长度，即字符个数，但凡存在于引号内（包括空格）的都算作字符
# msg = 'hello world'
# print(len(msg))

# (4)、成员运算in和not in
msg = 'hello world'
# print('el' in msg)
# print('el' not in msg)  # 推荐
# print(not 'el' in msg)

# (5)、移除空白strip
#  strip移除字符串首尾指定的字符,strip(self,chars)所提取的字符数
#  括号内不指定字符，默认移除首尾空白字符(空格、\n、\t)
# name = '       eg on       '
# print(name.strip())

# name = '*****eg on****'
# print(name.strip('*').replace(" ",''))

# msg = "*(&%&%&_+)**&^e*gon*)(^%$$&$"
# print(msg.strip('*()&%_+^%$'))

# x = 'a c d e'
# print(x.replace(' ','',1))
# print(x.replace(' ',''))

# 案例：
# inp_user = input("username>>>: ").strip()  # inp_user = "      egon"
# inp_pwd = input("password>>>: ").strip()
# if inp_user == "egon" and inp_pwd == '123':
#     print('ok')
# else:
#     print('no')

# (6)、切分split：把一个字符串按照某种分割符切分一个列表 
#split(self,chars)所提取的字符数
# msg = "egon:18:male:10"
# res = msg.split(':')
# print(res)
# print(res[0])

# res = msg.split(':',1)
# print(res)

# 6.1 把列表中的元素按照某种分隔符拼接成字符串
# info = ['egon', '18', 'male', '10']
#
# msg = ":".join(info)
# print(msg)

# (7)、循环
# msg = "hello world"
# for i in msg:
#     print(i)

# 需要掌握的操作（****）
# 1、strip,lstrip,rstrip
# print("******egon*****".strip('*'))
# print("******egon*****".lstrip('*'))
# print("******egon*****".rstrip('*'))

# 2、lower,upper
# print("AbC".lower())
# print("AbC".upper())

# 3、startswith,endswith
# print('hello world'.startswith('he'))
# print('hello world'.endswith('d'))

# print('hello world'.startswith('h'))
# print('hello world'.startswith('e',1,4))

# 4、format的三种玩法
# print("my name is %s my age is %s" % ('egon', 18))
# 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 {1} my age is {0}{0}{0}".format(18,'egon'))

# x = 'egon'
# y = 18
# print(f'my name is {x} ,my age is {y}')

# 5、split,rsplit
# msg = 'egon:18:male'
# print(msg.split(':',1))
# print(msg.rsplit(':',1))

# 6、replace     # 7、isdigit(方法检测字符串是否只由数字组成)

# print("18".isdigit())

# age = input('>>>: ').replace(' ', '')
# if age.isdigit():
#     age = int(age)
#     if age > 18:
#         print('too big')
#     elif age < 18:
#         print('too small')
#     else:
#         print('you got it')
# else:
#     print("必须输入数字，小垃圾")

# **----------------------需要的了解的操作（***）----------------------------**

#1、find,rfind,index,rindex,count

find：从指定范围内查找子字符串的起始索引，找得到则返回索引对应的数字，找不到则返回-1
index:同find,但在找不到时会报错

msg = 'hello egon ahahah egon xxx egon'
# print(msg.find('egon1'))
# print(msg.index('egon1'))
# print(msg.rfind('egon'))

#2、center,ljust,rjust,zfill

居中，左对齐，右对齐，（字符串右对齐显示，不够用0填充）

# print('egon'.center(50,'*'))总宽度为50，字符串居中，不够用*填充
# print('egon'.ljust(50,'*'))
# print('egon'.rjust(50,'*'))

# print('egon'.rjust(50,'0'))
# print('egon'.zfill(50))

#4、captalize,swapcase,title

首字母大写，大小写翻转，每个单词的首字母大写

# print('abcd'.capitalize())
# print('AbCd'.swapcase())
# print('my name is egon'.title())

#5、is数字系列
# print('18'.isdigit())
# print('Ⅳ'.isnumeric())

#isdecimal:uncicode(bytes类型无isdecimal方法)
#isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)
#总结:
    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
    如果要判断中文数字或罗马数字,则需要用到isnumeric。

#6、is其他
>>> name = 'tony123'
>>> name.isalnum() #字符串中既可以包含数字也可以包含字母
True
>>> name.isalpha() #字符串中只包含字母
False
>>> name.isidentifier()
如果字符串是有效标识符，则 isidentifier() 方法返回 True，否则返回 False。
如果字符串仅包含字母数字字母（a-z）或（0-9）或下划线（_），则该字符串被视为有效标识符。
有效的标识符不能以数字开头或包含任何空格。
True
>>> name.islower()  # 字符串是否是纯小写
True
>>> name.isupper()  # 字符串是否是纯大写
False
>>> name.isspace()  # 字符串是否全是空格
False
>>> name.istitle()  # 字符串中的单词首字母是否都是大写
False

# ======================================该类型总结====================================
# 存一个值
# 有序
# 不可变

**list**
# ======================================list基本使用===================================
# 1、用途

# 2、定义方式：在[]用逗号分隔开多个任意类型的元素
# l = [111,33.333,"aaaa",[666,7777]]  # l = list(...)
# print(type(l))

# list数据类型转换
# res = list("hello")
# print(res)

# 3、常用操作+内置的方法
# list无find方法
# 3.1 优先掌握的操作：
# 1、按索引存取值(正向存取+反向存取)：即可存也可以取
# l = [111,222,333,444,555,666,777]
# print(l[0])
# print(l[-1])
# print(id(l))
# l[0] = 999
# print(id(l))

# l[7] = 888  # 如果索引不存在则报错

# 2、切片(顾头不顾尾，步长)
# l = [111,222,333,444,555,666,777]
# print(l[1:4:1])  # 拷贝

# print(l[:])
# print(l[::-1])

# 3、长度
# l = [111,222,333,444,555,666,777]
# print(len(l))

# 4、成员运算in和not in
# l = [111,222,333,444,555,666,777]
# print(333 in l)

# 5、追加、插入
# append()列表尾部追加元素
# l = [111,222,333,444,555,666,777]
# l.append(888)

# insert()在指定位置插入元素
# l.insert(3,999999999999)
# print(l)

# 6、删除
l = [111, 222, 333, 444, 555, 666, 777]
# （1）万能删除
# del l[1]
# print(l)

# (2) l.remove()
# 括号内指名道姓表示要删除哪个元素，没有返回值
# v = l.remove(333)
# print(l)
# print(v)

# (3) l.pop() 
# 默认删除列表最后一个元素，有返回值，括号内可以通过加索引值来指定删除元素
# v = l.pop(2)
# print(l)
# print(v)

# 7、循环
# l = [111,222,333,444,555,666,777]
# for i in l:
#     print(i)

# 3.2 需要掌握
# l = [111,222,333,444,333,555,666,777]
# print(l.index(333))
# print(l.index(9999))

# print(l.count(333))

# l = [111,'a',333,'dddd']
# reserve 颠倒列表内元素顺序
# l.reverse()
# print(l)

# l = [111,'a',333,'dddd']
# l = [111, -3, 99, 27]
# 给列表内所有元素排序，排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
# l.sort(reverse=True)
# print(l)

# l = [111, -3, 99, 27]
# nums = [333,444,555]
# 列表尾部追加元素
# # l.append(nums)

# extend 
# 用于在列表末尾一次性追加另一个序列中的多个元素（用新列表扩展原来的列表）
# l.extend(nums)
# print(l)

# new_l = l.copy()
# new_l = l[:]

# ======================================该类型总结===================================
# 存多个
# 有序
# 可变

**tuple**
# ======================================元组基本使用======================================
# 1、用途：元组就是一种不可变的列表

# 2、定义方式：在()内用逗号分割开多个任意类型的元素
# t = (11,11.333,"aaa",[666,777])  # t = tuple()
# print(type(t))
#
# t[0] = 999

# t = (1111,)
# print(type(t))

# tuple数据类型转换
# print(tuple("hello"))

# 3、常用操作+内置的方法
# 优先掌握的操作：
# 1、按索引取值(正向取+反向取)：只能取
# 2、切片(顾头不顾尾，步长)
# 3、长度
# 4、成员运算in和not in

# 需要了解的
# t = (111,222,222,222,333)
# print(t.count(222))
# print(t.index(222))

# ======================================该类型总结====================================
# 存多个值
# 有序
# 不可变

t = (11, 22, [33, 44])
t[2][0] = 66

**队列是，先存入的数据最先取出，即“先进先出”。
栈是，最后存入的数据最先取出，即“后进先出”。**

**Python list实现队列**

使用 list 列表模拟队列功能的实现方法是，定义一个 list 变量，存入数据时使用 
insert() 方法，设置其第一个参数为 0，即表示每次都从最前面插入数据；读取数据时，
使用 pop() 方法，即将队列的最后一个元素弹出。
如此 list 列表中数据的存取顺序就符合“先进先出”的特点。实现代码如下：

1.  #定义一个空列表，当做队列
2.  queue = []
3.  #向列表中插入元素
4.  queue.insert(0,1)
5.  queue.insert(0,2)
6.  queue.insert(0,"hello")
7.  print(queue)
8.  print("取一个元素：",queue.pop())
9.  print("取一个元素：",queue.pop())
10.  print("取一个元素：",queue.pop())

['hello', 2, 1]
取一个元素： 1
取一个元素： 2
取一个元素： hello

**Python list实现栈**

使用 list 列表模拟栈功能的实现方法是，使用 append() 方法存入数据；使用 pop() 方法读取数据。
append() 方法向 list 中存入数据时，每次都在最后面添加数据，这和前面程序中的insert()方法正好相反。

1.  #定义一个空 list 当做栈
2.  stack = []
3.  stack.append(1)
4.  stack.append(2)
5.  stack.append("hello")
6.  print(stack)
7.  print("取一个元素：",stack.pop())
8.  print("取一个元素：",stack.pop())
9.  print("取一个元素：",stack.pop())

[1, 2, 'hello']
取一个元素： hello
取一个元素： 2
取一个元素： 1