整型

用途：一般用于定义整型，比如年龄，身份证号，QQ号

定义方式

age = 18    # age = int(18)

常用方法：数学计算，进制转换

print(bin(100))     # 十进制转二进制
print(oct(100))     # 十进制转八进制
print(hex(100))     # 十进制转十六进制
print(int('1100100', 2))    # 十进制转换任何类型，int('需要转换的十进制数',类型)

有序or无序：无序

可变or不可变：不可变

值变id不变的是可变类型

值变id也变的是不可变类型

存一个值or多个值：存一个值

 

浮点型

用途：用于记录小数，身高，体重，薪资等

 定义方式：

height = 1.0    # height = float(1.0)

常用方法：数学计算

类型总结：无序，不可变，存一个值

 

字符串

用途：用于存储一些描述性的信息，爱好，名字，性别

定义方式：

# 1、单引号
s1 = '大象'
# 2、双引号
s2 = "大象2"
# 3、三单引号/双引号
s3 = '''大象3'''
s4 = """大象4"""
print(s1)
print(s2)
print(s3)
print(s4)
# 以上三种方式没有任何区别，但不能混用
# 可以嵌套，比如内单外双，内双外单这样的
s5 = '我喜欢"大象"'
print(s5)
# 字符串前加一个小写的r，代表转义，转义为字符串
s6 = r"我喜欢'大象'1.234"
print(type(s6))

打印结果：
大象
大象2
大象3
大象4
我喜欢"大象"
<class 'str'>

优先掌握知识点***

1、索引取值（正向取、反向取），只能取不能存

s1 = 'hello world'
print(s1[1])    # 正向取字母e
print(s1[-10])  # 反向取字母e

打印结果：
e
e

2、索引切片：截取字符串中的一小段字符串

s1 = 'hello world'
print(s1[2:5])
print(s1[4:])
print(s1[:5])
print(s1[0:-2:2])
print(s1[::-1])

打印结果：
llo
o world
hello
hlowr
dlrow olleh

3、成员运算：in，not in

s1 = 'hello world'
print('o'in s1)
print('o' not in s1)

打印结果：
True
False

4、strip：去除字符串两边的空格，中间不算

　　input无论接收的是什么类型，一定返回字符串

a1 = '******kang******'     # 只想取出kang
print(a1.strip("*"))
# strip()里的符号可以自定义

打印结果：
kang

5、split：切分

　　作用：对字符串进行切分，可以指定切分的分隔符，返回是一个列表

a1 = 'kang|18|male'
print(a1.split('|'))

打印结果：
['kang', '18', 'male']

6、len：获取当前数据中的元素的个数

a = 'hello'
print(len(a))
for i in a:
    print(i)

打印结果：
5
h
e
l
l
o

需要掌握的知识点

7、restrip/lstrip

　restrip：去除右边的空格/字符

　lestrip：去除左边的空格/字符

a1 = '*******kang*******'
print(a1.rstrip('*'))
print(a1.lstrip('*'))

打印结果：
*******kang
kang*******

8、lower,upper

　lower：所有字符改成小写

　upper：所有字符改成大写

a1 = 'Kang'
print(a1.lower())
print(a1.upper())

打印结果：
kang
KANG

9、startswith/endswith  : 判断当前字符串是否以。。。开头，或者以。。结尾，返回的一定是布尔值

s1 = 'Hello world'
print(s1.startswith("He"))
print(s1.endswith('ld'))

打印结果：
True
True

10、.format/f-string

# 你的名字是：kang，你的年龄是：18
name = 'kang'
age = 21
print("你的名字是:", name, "你的年龄是,", age)
print("你的名字是：{}，你的年龄是：{}".format(name, age))
print("你的名字是：{0}，你的年龄是：{1}".format(name, age))
print("你的名字是：{name}，你的年龄是：{age},性别是：{gender}".format(age=age, name=name, gender='male'))
# f-string:
# 通过大括号接收变量，在字符串前面一定要加一个小写f，，，，在python3.6以后才有
print(f"你的名字是：{name}，你的年龄是：{age}")

打印结果：
你的名字是: kang 你的年龄是, 21
你的名字是：kang，你的年龄是：21
你的名字是：kang，你的年龄是：21
你的名字是：kang，你的年龄是：21,性别是：male
你的名字是：kang，你的年龄是：21

11、split，rsplit

s1 = 'name,age,gender'
print(s1.split(' , ', 1))   # 可指定切分次数

打印结果：
['name,age,gender']

12、join：将可迭代对象（l1列表中每个元素按照前面字符串中的分隔符进行拼接）

l1 = ['kang', '21', 'male']
print('|'.join(l1))

打印结果：
kang|21|male

13、replace:将字符串中的元素替换，参数先老值再新值

s1 = 'kang,21'
print(s1.replace('kang', 'zhao'))

打印结果：
zhao,21

14、isdigit:判断当前字符串中的数据是否为一个数字（可判断bytes,unicode）

score = input('请输入分数：')
if score.isdigit():
    score = int(score)
    if score >= 90:
        print('优秀')
else:
    print('你tmd能不能好好输')

了解的知识点

find / rfind / index / rindex / count

# find：查找当前字符串中某个元素的位置，返回索引，找不到就返回-1
s1 = '你今天吃饭吃了吗？'
print(s1.find("？", ))
# index  # 查找当前字符串中某个元素的位置，返回索引，找不到返回异常
print(s1.index("？"))
# count  # 统计当前字符串中某一个元素的个数
print(s1.count("吃"))

打印结果：
8
8
2

center \ ljust \ rjust \ zfill

print("欢迎光临".center(8,"-"))
print("欢迎光临".ljust(30,"-"))
print("欢迎光临".rjust(30,"-"))
print("欢迎光临".zfill(50))
s1 = """
kang\t18\tmale\t
zhao\t18\tfemale\t
"""
print(s1.expandtabs())
print(s1.expandtabs(20))

打印结果：
--欢迎光临--
欢迎光临--------------------------
--------------------------欢迎光临
0000000000000000000000000000000000000000000000欢迎光临

kang    18      male    
zhao    18      female  


kang                18                  male                
zhao                18                  female

is系列

a = b'10'
b = '10'
c = '十'
d = 'IV'
print(type(a))
print(b.isnumeric())
print(c.isnumeric())
print(d.isnumeric())
# isdigit: unicode,bytes
print(a.isdigit())
print(b.isdigit())

打印结果：
<class 'bytes'>
True
True
False
True
True

列表

用途：用于存一个或多个不同类型的值

定义方式：通过中括号存值，每个值之间通过都好进行分隔

常用方法：

1、索引取值（正反都可以取，不仅可取，还可以存）

l1 = [1, 2, 3, 4, 5, 6, 7]
print(l1[2])

打印结果：
3

2、索引切片

l1 = [1, 2, 3, 4, 5, 6, 7]
print(l1[2:5])
print(l1[4:])
print(l1[:5])
print(l1[0:-2:2])
print(l1[::-1])

打印结果：
[3, 4, 5]
[5, 6, 7]
[1, 2, 3, 4, 5]
[1, 3, 5]
[7, 6, 5, 4, 3, 2, 1]

3、append:追加值，只能添加到列表的最后，一次性只能添加一个值***

l1 = [1, 2, 3, 4, 5, 6, 7]
l1.append(1000)
print(l1)

打印结果：
[1, 2, 3, 4, 5, 6, 7, 1000]

4、insert：插入值，通过索引指定插入位置

l1 = [1, 2, 3, 4, 5, 6, 7]
l1.insert(3, 999)
print(l1)

打印结果：
[1, 2, 3, 999, 4, 5, 6, 7]

5、extend：追加必须是可迭代对象，在最后



l1 = [1, 2, 3, 4, 5, 6, 7]


l1.extend([8, 9])
print(l1)

打印结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9]




6、remove：指定值删除，比较彻底




l1 = [1, 2, 3, 4, 5, 6, 7]
l1.remove(1)
print(l1)

打印结果：
[2, 3, 4, 5, 6, 7]




7、pop：不传值，默认从最后开始删，指定索引删，pop是有返回值的




l1 = [1, 2, 3, 4, 5, 6, 7]
val = l1.pop(2)
print(l1)
print(val)

打印结果：
[1, 2, 4, 5, 6, 7]
3




 













    























            









							

   
版权声明：本文为aheng原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。



本文链接：https://www.cnblogs.com/aheng/p/11801112.html