学习内容:数据类型的内置方法

一数据类型的内置方法

数据为什么要分类型(掌握)

数据是用来表示状态的,不同的状态就应该用不同的类型数据去表示。比如姓名、身高和爱好,这三者就应用了不同的数据类型存储.

int(掌握)

  1. 用途:年龄、号码、等级
  2. 定义:可以使用int()方法将寸数字的字符串转为十进制的整型
    age = 19 # age =int(10)
    print(type(age))
    
    <class 'int'>
    
    x = int('111')
    print(type(x))
    
    <class 'int'>
    x = int('11.1')   # 报错
    print(x)
  3. 常用的操作+内置方法:算术运算+比较运算

长整型(了解)

长整型只在python2中存在,python3中不存在长整型。

x=11111111111111111111111111111111111111
print(type(x))
  1. 存一个值or多个值:一个值
  2. 有序or无序:无有序or无序一说

可变or不可变(掌握)

id不变值可变,即在原值的基础上修改,则为可变数据类型;质变id也变,即重新申请一个空间放入新值,则为不可变数据类型。

age = 19
print(f'first:{id(age)}')
age = 20
print(f'second:{id(age)}')

first:1774678048
second:1774678080
  1. 可变or不可变:不可变数据类型。

float(掌握)

  1. 用途:薪资、身高、体重
  2. 定义:可以使用float()方法将纯数字的字符转为浮点型数字。
    age = 5.2
    print(type(age))    # age = float(3.1)
    
    <class 'float'>
    x = float('520')
    print(x)
    print(type(x))
    
    520.0
    <class 'float'>
    
    x = float('52.1')
    print(type(x))
    
    <class 'float'>
    
  3. 常用操作+内置方法:算术运算+比较运算
  4. 存一个值or多个值
  5. 有序or无序:无有序or无序一说
    jin = 5.2
    print(f'first:{id(jin)}')
    jin = 5.21
    print(f'second:{id(jin)}')
    
    first:3674544
    second:3674592

二、字符串类型内置方法

str(掌握)

  1. 用途:描述性质的东西,例如人名、单个爱好、地址、国家等。
  2. 定义:使用‘‘、‘‘‘、""""""包裹的的一串字符
    • u‘unicode‘: unicode编码的字符串
    • b‘101‘: 二进制编码的字符串
    • r‘\n‘: 原生字符串,也就是说‘\n‘这是普通的两个字符,并没有换行的意思
    name = 'jin'  # name =str('jin')
    n1 = str(1.1)
    n2 = str([1, 2, 3])
    
    print(f's1:{n1}, type:{type(n1)}')
    print(f's2:{n2}, type:{type(n2)}')
    
    s1:1.1, type:<class 'str'>
    s2:[1, 2, 3], type:<class 'str'>
  3. 常用操作+内置方法:常用操作和内置方法分为优先掌握(今天必须得记住)、需要掌握(一周内记住)、其他操作(了解)三个部分。

    优先掌握

    1. 按索引取值
    2. 切片
    3. 长度len
    4. 成员运算in|not in
    5. 移除空白strip
    6. 切分split
    7. 循环
  4. 按索引取值
    hei = 'hello kim'
    
    print(f'索引为6:{hei[6]}')
    print(f'索引为-3:{hei[-3]}')
    
    索引为6:k
    索引为-3:k
  5. 切片(顾头不顾尾,步长)
    msg = 'hello jin'
    #      0123456789  # 索引序号
    
    print(f'切片3-最后: {msg[3:]}')
    print(f'切片3-8: {msg[3:8]}')
    print(f'切片3-8,步长为2: {msg[3:8:2]}')
    print(f'切片3-最后,步长为2: {msg[3::2]}')
    
    print('\n**了解知识点**')  # 了解,步长为正从左到右;步长为负从右到左
    print(f'切片所有: {msg[:]}')
    print(f'反转所有: {msg[::-1]}')
    print(f'切片-5--2: {msg[-5:-2:1]}')
    print(f'切片-2--5: {msg[-2:-5:-1]}')
    
    切片3-最后: lo jin
    切片3-8: lo ji
    切片3-8,步长为2: l i
    切片3-最后,步长为2: l i
    
    **了解知识点**
    切片所有: hello jin
    反转所有: nij olleh
    切片-5--2: o j
    切片-2--5: ij 
  6. 长度len
    msg = 'hello jin'
    
    print(len(msg))
    
    9
  7. 成员运算in和not in
    # str成员运算
    msg = 'my name is jin, jin handsome'
    
    print(f"'jin' in msg: {'jin' in msg}")
    print(f"'jason' not in msg: {'jason' not in msg}")
    print(f"not 'jason' in msg: {not 'jason' in msg}")
    
    'jin' in msg: True
    'jason' not in msg: True
    not 'jason' in msg: True
    
  8. 移除空白strip()
    # str移除空白strip()
    name = '&&&n jin'
    
    print(f"name.strip('&'): {name.strip('&')}")  # strip()默认为‘ ’,并且不修改原值,
    print(f"name: {name}")                          # 新创建空间
    pwd = input('password: ')   # strip()应用场景
    if pwd.strip() == '123':     #用户可能会手抖输入空格
        print('密码输入成功')
    
    print(f"'*-& jin+'.strip('*-& +'): {'*-& jin+'.strip('*-& +')}")
    
    name.strip('&'): n jin
    name: &&&n jin
    password: 
  9. 切分split
    # str切分split
    info = 'jin:male:19'
    info_list1 = info.split(':')
    info_list2 = info.split(':', 1)
    
    print(f'info_list1:{info_list1}')
    print(f'info_list2:{info_list2}')
    
    info_list1:['jin', 'male', '19']
    info_list2:['jin', 'male:19']
  10. 循环
    msg = 'hello jin zhen dong'
    
    for i in msg:
        print(i)
    
    h
    e
    l
    l
    o
    
    j
    i
    n
    
    z
    h
    e
    n
    
    d
    o
    n
    g
    

需要掌握

  1. lstrip&rstrip
  2. lower&upper
  3. startswith&endswith
  4. rsplit
  5. join
  6. replace
  7. isdigit

1.lstrip()和rstrip()

# str之lstrip()和rstrip()
name = '&&jin&&'

print(f"jin.lstrip('&'): {name.lstrip('&')}")
print(f"jin.rstrip('&'): {name.rstrip('&')}")

jin.lstrip('&'): jin&&
jin.rstrip('&'): &&jin

2.lower()和upper()

# str之lower()和upper()
name = 'jin zhen dong'

print(f"name.upper(): {name.lower()}")
print(f"name.upper(): {name.upper()}")

name.upper(): jin zhen dong
name.upper(): JIN ZHEN DONG

3.startswith()和endswith()

 str之startswith()和endswith()
name = 'jin zhen dong'

print(f"name.startswith('jin'): {name.startswith('jin')}")
print(f"name.endswith('zhen dong'): {name.endswith('zhen dong')}")

name.startswith('jin'): True
name.endswith('zhen dong'): True

4.rsplit()

# str之rsplit()
info = 'jin:male:19'

print(f"info.rsplit(':', 1): {info.rsplit(':', 1)}")  # 从右开始切割

info.rsplit(':', 1): ['jin:male', '19']

5.join()

lis = [1,2,'19']         # 报错,数字不可和字符串拼接
print(f"':'.join(lis): {':'.join(lis)}")  
lis = ['jin', 'male', '19']   # str之join()

print(f"':'.join(lis): {':'.join(lis)}")

':'.join(lis): jin:male:19

6.replace()

# str值replace()
name = 'jin shuai'

print(f"name.replace('shuai','handsome'): {name.replace('shuai','handsome')}")

name.replace('shuai','handsome'): jin handsome

7.isdigit()

# str值isdigit()
salary = '111'
print(salary.isdigit())  # True

salary = '111.1'
print(salary.isdigit())  # False

True
False
# str之isdigit()应用场景
age = input('age: ')
if age.isdigit():
    age = int(age)

    if age < 18:
        print('小姐姐')
    else:
        print('阿姨好')
else:
    print(f'你的年龄能是这个{age}?')

age: haha
你的年龄能是这个haha?

原文地址:https://www.cnblogs.com/jincoco/p/10915484.html

时间: 2024-10-05 02:55:36

学习内容:数据类型的内置方法的相关文章

数据类型及内置方法

数据类型及内置方法 一.数字类型 1.int整型      (不可变类型,一个值) print(int(3.1)) # res=int('1111111') # print(res,type(res)) 整型可接收纯数字组成的字符串.浮点型或者是阿拉伯数字 在python中十进制转换为二进制   bin(x) 转换为八进制   oct(x) 转换为16进制 hex(x) 2.float浮点型      (不可变类型,一个值) 同int # res=float('111111.1') # prin

数据类型的内置方法:集合

目录 数据类型的内置方法:集合 作用 定义 优先掌握的内置方法 数据类型的内置方法:集合 作用 用于关系运算的集合体,由于集合内的元素无序且集合元素不可重复,因此集合可以去重,但是去重后的集合会打乱原来元素的顺序. 一个值or多个值:多个值,且值为不可变数据类型 有序or无序:无序 可变or不可变:可变 定义 {} 内用逗号分隔开多个元素,每个元素必须是不可变类型. s = {1,2,1,'a'} # s = set({1,2,'a'}) print(s) # {1,2,'a'} 优先掌握的内置

数据类型的内置方法:元组

目录 数据类型的内置方法:元组 作用 定义 优先掌握的内置方法 数据类型的内置方法:元组 作用 能够存储多个元素,元素与元素之间逗号隔开 ,元素可以是任意类型,元组不能被修改. 存一个只or多个值:多个值 有序or无序:有序 可变or不可变:不可变 定义 num = (1,2,3,4,5,6) # num = tuple((1,2,3,4,5,6)) 优先掌握的内置方法 1:按索引取值(正向或反向取),只能取 num = (1,2,3,4,5,6) print(num[5]) # 6 2:切片(

Python之基本数据类型及内置方法

Python之基本数据类型及内置方法 数字类型 整型 1.作用 年龄/id 2.定义方式 x = 10 3.使用方法 + - * / % // ** < <= > >= == != 4.有序or无序 有索引的就有序,无索引的就无序 压根就没有有序无序一说 5. 可变or不可变 值变id不变叫可变,值不变id变叫不可变 整型不可变 x = 10 print(id(x)) x += 1 print(id(x)) 浮点型 1.作用 薪资 2.定义方式 x = 10.1 3.使用方法 +

python学习的第六天数据类型及内置方法part2

一.元祖:就是一个不可变的列表 1.用途:用于存放多个值,当存放的多个值只能读的需求没有改的需求时用元祖最合适 2.定义方式:在()内用逗号分隔开多个任意类型的值 # t=(1,) # print(t,type(t) 3.常用的操作和内置的方法 (1)按索引取值(正向取,反向取):只能取 (2).切片(顾头不顾尾,步长) # t=('h','e','l','l','o') # res=t[1:3] # print(res) # print(t) (3)长度(len) (4)成员运算in和not

05 基本数据类型及内置方法

[TOC] 一 引子 ? 数据类型是用来记录事物状态的,而事物的状态是不断变化的(如:一个人年龄的增长(操作int类型) ,单个人名的修改(操作str类型),学生列表中增加学生(操作list类型)等),这意味着我们在开发程序时需要频繁对数据进行操作,为了提升我们的开发效率, python针对这些常用的操作,为每一种数据类型内置了一系列方法.本章的主题就是带大家详细了解下它们,以及每种数据类型的详细定义.类型转换. 插图:恶搞图01 二 数字类型int与float ##2.1 定义 # 1.定义:

数据类型及内置方法2

字符串的内置方法 以下了解 #find,rfind,index,rindex,count name='egon say hello'print(name.find('o',1,3)) #顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引 print(name.index('e',2,4)) #同上,但是找不到会报错 print(name.count('e',1,3)) #顾头不顾尾,如果不指定范围则查找所有 #center,ljust,rjust,zfill name='egon'print

所有数据类型的内置方法

str的内置方法 str.endswith(字符串)/startswith(字符串) 判断str是否以字符串结尾/开头 str.format() 格式化字符串 str.split('分割点',切分次数)/rstrip 将字符串以分割点切分成列表 str.replace(原字符,目标字符,修改次数) 将str中的特定字符转化成目标字符 str.index(元素,起始索引,终止索引)/rindex 查找元素,返回找到的第一个索引(找不到则报错) str.find(元素,起始索引,终止索引)/rfin

基本数据类型及内置方法

一.数字类型int与float 1.基本方法: 用途: int一般用于定义整数:年龄.身份证号.手机号等 float一般用于记录小数:身高.体重等 定义方法: age = 18      #      age = int(18) high = 1.87   #     high = float(1.87) 2.类型总结: 有序or无序(有索引的都是有序的): int类型无序,float类型也是无序 可变or不可变: 值改变id不变就是可变类型,值改变id也变就是不可变类型 int类型是不可变类型