数据类型的基本使用及内置方法

整型int 的基本使用

• 作用：用来记录年龄、人数、号码、等整数相关的状态

  age = 18  # 本质age = int(18)
  print(type(age))  # <class 'int'>

常用操作

• 数学运算 + 比较运算 ```python

  1.类型转换：只能把纯数字组成的字符串转成整型，代码中展示出来的效果就是 名字()

  res = int(“18”)

  print(res) # 18

LONG类型 在python2中（python3中没有长整形的概念）

2.进制转换：

print(bin(11)) # bin十进制转二进制 0b1011

print(oct(11)) # oct十进制转八进制 0o13

print(hex(11)) # hex十进制转十六进制 0xb

0b开头为二进制数 0o开头为八进制数 0x开头为十六进制数

print(int(‘0b1011’, 2)) # 11

print(int(‘0o13’, 8)) # 11

print(int(‘0xb’, 16)) # 11

x = 1 - 2j

print(type(x)) # complex复数

print(x.real) # 1.0 实步

print(x.imag) # -2.0 虚步

- 该类型总结： 
   - 只能存一个值
   - 不可变类型
---
<a name="4e1a460e"></a>
## 浮点型float的基本使用
- **作用：**用来记录身高、体重、薪资等小数相关的状态
```python
 salary = 3.1  # 本质 salary = float(3.1)
 print(type(salary))  # <class 'float'>

常用操作

• 数学运算 + 比较运算

  # float数据类型转换: 可以把小数组成的字符串转成浮点型
  res=float(111)
  print(res,type(res))  # 111.0 <class 'float'>
  res=float("    3.3    ")
  print(res,type(res))  # 3.3 <class 'float'>

• 该类型总结：

  • 只能存一个值
  • 不可变类型

字符串str的基本使用

• 作用：用来记录姓名、性别、国籍、家庭地址等描述性质的状态
• 定义方式：在””，’’，””””””，’’’’’’内包含一串字符

msg = "abc"  # 本质 msg = str("abc")
print(type(msg))  # <class 'str'>

• 注意：
  • 1、上述引号定义出来的都是 str 类型，没有区别
  • 2、三引号可以存放多行字符串
  • 3、引号的嵌套：外层双引号，内层只能用单引号

# 数据类型转换：str可以把任意类型都转成字符串类型
res = str([1,2,3])  # 列表转字符串类型
print(res,type(res))  # [1, 2, 3] <class 'str'>

<<< 补充知识点>>>

# 右斜杠的概念:  \n
 print("abc\nddd")
 print(r"abc\nddd")   # √
 print("abc\\nddd")   # √
 print('abc\nddd')  
 file_path=r'D:\new\a.py'  # 加r前缀
 file_path='D:\\new\\a.py' # 双斜杠转意
 print(file_path)    # D:\new\a.py

str 常用操作

优先掌握的操作

1、索引取值(正向取+反向取)：只能取

 msg = "hello world"
 print(msg[0],type(msg[0]))  # h <class 'str'>
 print(msg[-1])  # d
 msg[0]="H"  # 报错！只能取不能改

2、切片 (顾头不顾尾，步长)

 msg = "hello world"
 res = msg[1:7]  # 索引从1开始取到7结束，空格也算字符
 print(res)  # ello w
 res = msg[1:7:2]  # 1 3 5
 print(res)  # el 
 res = msg[:]  # 复制字符串，原始写法 msg[::1] 
 print(res)  # hello world
 res = msg[::-1]  # 倒着取，原始写法 msg[10::-1]
 print(res)  # dlrow olleh

3、统计字符串内部字符的个数 len

 msg = "hello world"
 print(len(msg))  # 11

4、成员运算in和not in

 msg = "hello world"
 print("he" in msg)  # True
 print("he" not in msg)  # False 推荐使用
 print(not "he" in msg)  # False

5、移除空白 strip

msg = "    hello    "
res = msg.strip()
print(res)
print(msg)
# strip移除*号
msg = "********hello**********"
print(msg)
print(msg.strip("*"))
# strip移除符号
msg = "+*-he*llo***%/*"
print(msg.strip("*+-/%"))
# strip应用用户登录验证案例：
inp_name = input("username: ").strip()  # inp_name = "jack "
inp_pwd = input("password: ").strip()
if inp_name == "jack" and inp_pwd == "123":
    print('ok')
else:
    print('no')

6、切分split，rsplit 把一个字符串按照某一个分隔符切割成列表，split 指定切几刀从左往右切，rsplit 指定切几刀从右往左切

msg = "jack:123:3000"
print(msg[0:4])  # jack
# split（）指定切几刀从左往右切，该方法的结果是一个列表
res = msg.split(":")
print(res)  # ['jack', '123', '3000']
res = msg.split(":", 1)  # 指定切分次数
print(res)  # ['jack', '123:3000']
# rsplit（）指定切几刀从右往左切，该方法的结果是一个列表
res = msg.rsplit(":",1)
print(res)  # ['jack:123', '3000']

7、循环

name = 'jack'
for x in name:  # 依次取出字符串中每一个字符
  print(x)
'''
j
a
c
k
'''

str 内置方法

需要掌握的操作

1、strip（去除左右两边）lstrip（去除左边）rstrip（去除右边）

msg = "****hello****"
print(msg.strip("*"))  # hello
print(msg.lstrip("*"))  # hello****
print(msg.rstrip("*"))  # ****hello

2、lower（全部转小写）、 upper（全部转大写）

res = 'JasOn123 JAson'
# 转全小写
print(res.lower())  # jason123 jason
# 转全大写
print(res.upper())  # JASON123 JASON
"""
实际案例:图片验证码忽略大小写
思路:全部转大写或者小写再比对
"""
old_code = 'JaSon123'
print('这是返回给用户的图片验证码:%s' % old_code)
new_code = input('请输入验证码>>>:').strip()
if old_code.upper() == new_code.upper():  # 这里也可以使用lower()
    print('验证码正确')
else:
    print('验证码错误')
# 示例
res = 'JASON123'
res1 = 'jason123'
# 判断是否是纯大写
print(res.isupper())  # True
print(res1.isupper())  # False
# 判断是否是纯小写
print(res.islower())  # False
print(res1.islower())  # True

3、startswith（判断开头）， endswith（判断结尾）

msg = "jack is ok"
print(msg.startswith("jack"))  # True
print(msg.startswith("ja"))   # True
print(msg.startswith('tony'))  # False
print(msg.endswith("ok"))  # True
print(msg.endswith("k"))  # True
print(msg.endswith('is'))  # False

4、format的三种玩法

# 与用户交互 占位符 %s %d
 msg = "my name is %s my age is %s" %("jack",18)
# 字符串内置方法 format()
# 第一种玩法 相当于%s占位符
 msg = 'my name is {} my age is {}'
 print(msg.format('jack',18))  # my name is jack my age is 18
# 第二种玩法 大括号内写索引值可以打破顺序 并且可以反复使用相同位置的数据
 msg = '{1} my name is {1} my age is {0} {0} {0} {1} {1}'
 print(msg.format('jack', 18))
# 第三种玩法 大括号内写变量名
 msg = "my name is {name} my age is {age}".format(age=18,name="jack")
 print(msg)  # my name is jack my age is 18
'''
占位符与format结合具体情况挑选使用
字符串格式化推荐用format，相比%s效率更高
'''
# 补充(传字典需要加特殊符号**)
 msg = "my name is {name} my age is {age}".format(**{"age":18,"name":"jack"})
 msg = "my name is %(name)s my age is %(age)s" % {"age":18,"name":"jack"}
 print(msg)  # my name is jack my age is 18
 name = "jack"
 age = 18
 print(f"my name is {name} my age is {age}")  # my name is jack my age is 18

5、join（把列表用某一个连接符重新再拼接成字符串）

l = ["jack","18","3000","44444"]
# 方式一：利用索引手动拼接
 print(l[0]+":"+l[1]+":"+l[2]+":"+l[3])  # jack:18:3000:44444
# 方式二：用join进行拼接
 print(":".join(l))  # jack:18:3000:44444

6、replace（新值替换旧值）

msg = 'jack xxxx jack yyy jack'
res = msg.replace('jack',"JACK",1)  # 写几次换几次 -1全换
print(res)  # JACK xxxx jack yyy jack
res = msg.replace('jack',"JACK")  # 不写次数，默认全换
print(res)  # JACK xxxx JACK yyy JACK
msg = "**_+_***he llo***+-**"
res = msg.strip("*_+-").replace(" ",'')
print(res)  # hello

8、isdigit（判断字符串是否为纯数字）

msg = 'jason123'
print(msg.isdigit())  # False
num = '123'
print(num.isdigit())  # True
# 示例
num = input("请输入>>>: ")  # num = "asfasdf"
if num.isdigit():
  num = int(num)
  print(num > 10)
else:
    print("必须输入数字，小垃圾")

了解即可

1、find，rfind，index，rindex，count

 msg = 'hello el abc'
# find（）：查看指定字符对应的起始索引值，从左往右进行查找，找得到则返回数字1，找不到则返回-1
 res=msg.find("el") 
 print(res)  # 1
# rfind（）：从右往左进行查找，返回真实的索引位置，找不到返回-1
 res=msg.rfind("el")
 print(res)  # 6
# index（）：查找索引值，找不到的话会报错。
 res=msg.index("el")
 print(res)  # 1
# rindex（）：从右边进行查找，返回真实的索引位置，找不到抛出异常
 res=msg.rindex("el")
 print(res)  # 6
 res=msg.find("xxx")
 print(res)  # -1
 res=msg.index("xxx")  # 找不到则报错
# count（）：统计某个字符出现的次数(记忆)
 res = msg.count('el')
 print(res)  # 2

2、center，ljust，rjust，zfill

# center（）：用指定的字符来填充字符串，使得字符串居中
 print('hello'.center(15,'*'))  # *****hello*****
# ljust（）：和center是类似的，仅仅是在左边
 print('hello'.ljust(15,'*'))  # hello**********
# rjust（）：和center是类似的，仅仅是在右边
 print('hello'.rjust(15,'*'))  # **********hello
# zfill（）：在开头添加指定的长度的0，类似于：'hello'.rjust(50,'0')
 print('hello'.zfill(15))  # **********hello

3、captalize，swapcase，title

# capitalize（）：将字符串首字母大写
 print("hello world".capitalize())  # Hello world
# swapcase（）：大写变成小写，小写变成大写
 print("aAbB".swapcase())  # AaBb
# title（）：按照title的格式将字符串进行修改
 print("hello world".title())  # Hello World

4、is 数字系列

# 在python3中
 num1=b'4'  # bytes
 num2=u'4'  # unicode，python3中无需加u就是unicode
 num3='四'  # 中文数字
 num4='Ⅳ'  # 罗马数字
# bytes、unicode
 print(num1.isdigit())  # True
 print(num2.isdigit())  # True
 print(num3.isdigit())  # False
 print(num4.isdigit())  # False
# unicode
 print(num2.isdecimal())  # True
 print(num3.isdecimal())  # False
 print(num4.isdecimal())  # False
# unicode、中文数字、罗马数字
 print(num2.isnumeric())  # True
 print(num3.isnumeric())  # True
 print(num4.isnumeric())  # True

5、is 其他

 name="JACK123"
 print(name.isalpha())  # False 只能由字母组成
 print(name.isalnum())  # True 字母或数字组成
 print(name.islower())  # False 小写或数字组成
 print(name.isupper())  # True 大写或数字组成
 name="               "
 print(name.isspace())  # True 是否为空格
 name="Hello world"
 print(name.istitle())  # False 是否为title格式

• 该类型总结：
  • 存一个值
  • 有序
  • 不可变

列表list的基本使用

• 用途：按照索引存放多个任意类型的值，每个位置代表一个元素
• 定义方式：在[ ]内用逗号分隔开多个任意类型的值

l = [11,11.33,"xxx",[11,22,33]]  # l = list(...)
 print(type(l))  # <class 'list'>
# 列表内一般都会存储相同数据类型的数据
# list数据类型转换：把可迭代的类型转成列表（即支持for循环的数据类型转换成列表）
 print(list(123))  # 报错
 print(list(123.21))  # 报错
 print(list('hello'))  # ['h', 'e', 'l', 'l', 'o']
 print(list({'name': 'jason', 'pwd': 123}))  # ['name', 'pwd']
 print(list((11, 22, 33)))  # [11, 22, 33]
 print(list({11, 22, 33}))  # [33, 11, 22]
# 可以被for循环遍历的类型都是可迭代的
 res = list("hello")
 print(res)  # ['h', 'e', 'l', 'l', 'o']
 res = list({"k1":111,'K2':2222})
 print(res)  # ['k1', 'K2']
 print(list(range(1000)))

list 常用操作

优先掌握的操作

1、按索引存取值(正向存取+反向存取)：即可存也可以取

l = [111,222,333]
 print(id(l))  # 140665613558536
 l[0] = 666  # 将索引0的值改为666
 print(l)  # [666, 222, 333]
 print(id(l))  # 140665613558536 内存地址不会发生变化
# l[3] = 777  # 报错！列表索引不能超出范围

2、切片（顾头不顾尾，步长）

 l = [11,22,33,44,55,66,77,88,99]
 res = l[1:7:2]  # 从索引1开始切，7结束，每次间隔2
 print(res)  # [22, 44, 66]
 res = l[:]  # 复制 copy
 print(res)  # [11, 22, 33, 44, 55, 66, 77, 88, 99]
 res = l[::-1] # 复制降序
 print(res)  # [99, 88, 77, 66, 55, 44, 33, 22, 11]

3、统计列表内元素的个数（长度）

 l = ["aaa", 111, 2222]
 print(len(l))  # 3

4、成员运算in和not in

l = ["aaa",111,2222]
print(111 in l)  # True
print(333 not in l)  # True

5、添加值

# 方式1：尾部追加(将括号内的数据当成一个整体追加到列表末尾)
 l = [111,222,333]
 l.append(444) 
 l.append(555)
 print(l)  # [111, 222, 333, 444, 555]
# 方式2：插入元素(将括号内的数据当成一个整体插入到索引指定位置)
 l = [111,222,333]
 l.insert(1,6666)  # 索引1的位置插入值6666
 print(l)  # [111, 6666, 222, 333]
 l = [111,222,333]
 res = l.append(444)  # 值
 res = l.insert(1,444)
 print(res)  # None
 print(l)  #  [111, 444, 222, 333, 444]  
# 方式3：扩展元素，往列表里面一次加多个值(相当于for循环+append操作)
 l = [111, 222, 333]
 l.extend([444, 555, 666])
 print(l)  # [111, 222, 333, 444, 555, 666]
 l1 = [111, 222, 333]
 l2 = [444, 555, 666]
 for i in l2:
      l1.append(i)
 print(l1)  # [111, 222, 333, 444, 555, 666]

6、删除

 l = [111,222,333]  
# del 万能删除，del是关键字delete缩写
 del l[0]  # 根据索引直接删除 
 print(l)  # [222, 333]
# remove(指定元素)
 res = l.remove(222) # 括号内指定需要移除的元素值
 print(l)  # [111, 333]
 print(res)  # None
# pop(指定索引)
 res = l.pop(1)  # 括号内指定需要弹出的元素索引值
 print(l)  # [111, 333]
 print(res)  # 222 可以有返回值
 res = l.pop()  # 括号内如果不写参数则默认弹出列表尾部元素
 print(l)  # [111, 222]
 print(res)  # 333

7、循环

l = [111,222,333]
for x in l:
   print(x)
'''
111
222
333
'''   
for i,x in enumerate(l):
   print(i,x)
'''
0 111
1 222
2 333 
'''

list 内置方法

需要掌握的操作

l = [11, 22, 33, 44, 33, 55]
new_l = l.copy()   # 相当于 new_l = l[:] 浅拷贝
print(new_l)  # [11, 22, 33, 44, 33, 55]
# len()：列表内元素的个数（长度）
print(len(l))  # 6  就是 l._len_()  
# index()：查看某一个元素出现的索引
print(l.index(33))  # 2 对应2号索引
# print(l.index(777))  # 找不到就报错
# count()：统计某一个元素出现的个数
print(l.count(33)) # 3  出现3次
# clear()：清空列表，把列表里面所有元素都删掉
l.clear()
print(l) # [] 剩下空列表
# reverse()：把列表里面的元素倒过来
l.reverse()
print(l)  # [55, 33, 44, 33, 22, 11]
# sort()：排序
l = [11, -3, 9, 7, 99, 73]
l.sort()  # 默认从小到大的顺序
print(l)  # [-3, 7, 9, 11, 73, 99]
l.sort(reverse=True)  # 从大到小的顺序
print(l)  # [99, 73, 11, 9, 7, -3]

• 该类型总结：
  • 存多个值
  • 有序
  • 可变

可变不可变类型

可变类型：值改变，内存地址不变，其实就是在修改原值，原值是可变类型

 l = [111,222,333]
 print(id(l))  # 140478665085320
 l[0] = 66666  # 将索引0的值改为66666
 print(l)  # [66666, 222, 333]
 print(id(l))  # 140478665085320

不可变类型：值改变，内存地址肯定变，其实是产生了新值，原值是不可变类型

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