python 之 数据类型初接触

python 之 数据类型初接触

标准数据类型

Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

1,整型, 2.浮点型,3.字符串, 4.列表,5.元组,6.字符串

一.)整型(int)
======================================基本使用======================================
    1、用途:存qq号，手机号，不带字母的身份证号.整数型适用场景..

    2、定义方式
        age = 18   age = int(18)
        int('dsjfjdsf')
        int('1.1')   int只能转纯数字的字符串，小数点都不行

        进制转换

        其他进制转10进制
        二进制转十进制  0,1
            10   1*(2**1) + 0*(2**0)  2
        八进制转十进制  0-7
            235  2*(8**2) + 3*(8**1) + 5*(8**0)
        十六进制转十进制 0-9 A-F
            217  2*(16**2) + 1*(16**1) + 7*(16**0)
        print(int('1100',2))   int可以传第一个参数，表示的是第一个参数到底是什么进制  然后转成十进制
        print(int('14',8))
        print(int('c',16))

        10进制转其他进制
        10进制转二进制
        print(bin(12))   0b1100  0b表示后面的数字是二进制数
        10进制转八进制
        print(oct(12))   0o14  0o表示后面的数字是八进制数  14 >>> 1*(8**1) + 4*(8**0))
        10进制转16进制
        print(hex(12))   0xc  0x表示后面的数字是十六进制数

        3、常用操作+内置的方法
        ======================================该类型总结====================================
        存一个值
        有序or无序
          有序：但凡有索引的数据都是有序的
        不可变

        可变类型与不可变类型
        """
        可变类型:值改变的情况下，id不变,说明你改的是原值
        不可变类型:值改变的情况下，id一定变
        """
        x = 10
        print(id(x))
        x = 11
        print(id(x))

二. 浮点型
    用途:精准的标记,运算
     作用:薪资 身高 体重
    定义方式:
     salary = 1.1    float(1.1)
    res = float('1.11')
    print(type(res))
      *****字符串********字符串********字符串********字符串********字符串********字符串**
    ======================================基本使用======================================
三.字符串

    1、用途:描述性数据
    2、定义方式:'' ,   """  """ ,
     s = 'hello baby'   str('hello baby')
     s1 = str([1,2,3,4])
     print(type(s1))
     s2 = str({'name':'jason','password':123})
     print(type(s2))

    1、按索引取值(正向取+反向取) ：只能取
     s = 'hello big baby~'
     print(s[0])
    2、切片(顾头不顾尾，步长):从一个大的字符串中截取一段新的小字符串
     左边的固定就是头，右边固定就是位  没有说按数字来分头尾
     print(s[0:5])   hello
     print(s[0:10:1])   hello  步长不写默认是1
     print(s[0:10:2])   步长表示隔几个取一个
     了解负数取值
     print(s[-1])
     print(s[0:5:-2])   切片取值默认是从左往右的
     print(s[5:0:-1])   切片取值默认是从左往右的
     print(s[-1:-10:-1])

    3、长度len：统计的是字符串中字符的个数
     s1 = ' '
     print(len(s1))
    4、成员运算in和not in: 判断一个子字符串是否存在于一个大的字符串中
     print('egon' in 'egon is dsb and egon is sb')
     print('g' in 'egon is dsb and egon is sb')
     print('jason' not in 'egon is dsb and egon is sb')

    5、去掉字符串左右两边的字符strip，不管中间的
     username = input('>>>:').strip()
     if username == 'jason':
         print('good job')
     strip()默认去除字符串首尾的空格
     使用内置的方法统一采用 句点符(.)
     name1 = 'jason'
     name2 = '   jason   '.strip()
     print(name1 == name2)
     name3 = '$$$$$eg$on$$$$'
     print(name3.strip('$'))

     name4 = '% ￥jason&*)'
     print(name4.strip('% ￥)'))
    调用字符串的方法并没有改变字符串本身

     rstrip() lstrip()
     name5 = '$$$$jason$$$$'
     print(name5.lstrip('$'))   left左边
     print(name5.rstrip('$'))   right右边

    6、切分split:针对按照某种分隔符组织的字符串，可以用split将其切分成列表，进而进行取值
     data = 'jaso n|123| handsome'
     print(data.split('|'))
     username,password,info = data.split('|')
     print(username,password,info)
     强调:split切分出来的数据类型是一个列表
     print(data.split('o'))   切割的顺序其实从左往右的
     print(data.split('o',1))   切割的顺序其实从左往右的
     print(data.rsplit('o',1))   切割的顺序其实从左往右的
     如果不指定那么split和rsplit效果是一样

    7、循环
     for i in data:
         print(i)

1、strip,lstrip,rstrip

2、lower,upper
 s = 'JaS1oN'
 res = s.lower()
 print(res)
 print(s)
 print(s.upper())
 print(s)
 调用字符串的方法并没有改变字符串本身

3、startswith,endswith
 s1 = 'egon is dsb'
 print(s1.startswith('e'))   判断字符串是否以什么什么开头
 print(s1.endswith('n'))   判断字符串是否以什么什么结尾

4、format的三种玩法（python推荐使用format做格式化输出）
 第一种  按位置占位   跟%s原理一致
 str1 = 'my name is {} my age is {}'.format('jason',18)
 str1 = 'my name is {} my age is {}'.format(18,'jason',)
 print(str1)
 第二种  按索引占位
 str1 = 'my {1} name is {0} my {0} age is {0}'.format('egon',18)
 print(str1)
 第三种  指名道姓占位（关键字传参）
 str1 = 'my {name} name is {age} my {name} age is {name}'.format(name='jason',age=18)
  print(str1)

5、split,rsplit
6、join
 data = 'jason|123|handsome'
 res_list = data.split('|')
 print(res_list)

 res_str = '$'.join(res_list)   将容器类型中的多个元素通过指定字符拼接成一个字符串
 print(res_str)
 l = ['1','a','b']
 res = '|'.join(l)
 print(res)

7、replace
 str = 'egon is dsb and egon is sb he has a BENZ'
 res = str.replace('egon','kevin',1)
 print(res)
 print(str)

8、isdigit  判断字符串中包含的是否为纯数字
 while True:
     age = input('>>>:')
     if age.isdigit():
         age = int(age)
         if age > 28:
             print('阿姨好')
     else:
         print('你他妈的能不能好好输')

 l=[564,654,6549879,465,132,1,89,c ,8735,4]
 l.append('asd')

1、find,rfind,index,rindex,count
 s = 'kevin is dsb o and kevin is sb'
 print(s.find('dsb'))   返回的是d字符所在的索引值
 print(s.find('xxx'))   找不到的时候不报错返回的是-1
 print(s.find('i',0,3))   还可以通过索引来限制查找范围
 print(s.index('o'))   返回所传字符所在的索引值
 print(s.index('i',0,3))   返回所传字符所在的索引值
 print(s.count('n'))   统计字符出现的次数

2、center,ljust,rjust,zfill
 s9 = 'jason'
 print(s9.center(12,'*'))
 print(s9.ljust(40,'$'))
 print(s9.rjust(40,'$'))
 print(s9.rjust(40,' '))
 print(s9.zfill(40))

3、expandtabs

 s10 = 'a\tbc'
 print(s10.expandtabs(100))

4、captalize,swapcase,title
 s12 = 'hElLo WoRLD sH10'
 print(s12.capitalize())   Hello world 首字母大写
 print(s12.swapcase())   大小写互换
 print(s12.title())   每个单词的首字母大小

5、is数字系列
 num1=b'4' bytes
 num2=u'4' unicode,python3中无需加u就是unicode
 num3='壹' 中文数字
 num4='Ⅳ' 罗马数字
 ''.isnumeric(): unicode,中文数字，罗马数字    只要是表示数字都识别
 print(num2.isnumeric())
 print(num3.isnumeric())
 print(num4.isnumeric())

 ''.isdecimal(): unicode   只识别普通的阿拉伯数字
 print(num2.isdecimal())
 print(num3.isdecimal())
 print(num4.isdecimal())

 ''.isdigit() :bytes,unicode    通常情况下使用isdigit就已经满足需求了
 print(num1.isdigit())
 print(num2.isdigit())
 print(num3.isdigit())
 print(num4.isdigit())

3、常用操作+内置的方法
======================================该类型总结====================================
存一个值
有序(有序：但凡有索引的数据都是有序的)
不可变类型

l=[asd,654,56486,7,51,3,546,7,94,64]
l.append('5')
print(l)
作用：多个装备，多个爱好，多门课程，多个女朋友等

定义：[]内可以有多个任意类型的值，逗号分隔
 my_girl_friends=['alex','wupeiqi','yuanhao',4,5] 本质my_girl_friends=list([...])
 或
 l=list('abc')
 l1=list({'name':'jason','password':'123'})
 print(l1)
 list内部原理就是for循环取值 然后一个个塞到列表中去

优先掌握的操作：
1、按索引存取值(正向存取+反向存取)：即可存也可以取
 l = [1,2,3,4]
 print(l[0:4:1])
 print(l[0::])
 print(l[5::-1])
 print(id(l))
 l[0] = 69
 print(id(l))
 print(l)
2、切片(顾头不顾尾，步长)
l = [11,22,33,44,55]
l1 = [99,88,77,66]
 [11,22,33,44,55,99,88,77,66]

 1.尾部添加一个66
 l.append(66)   注意append值能将被添加的数据当作列表的一个元素
 print(l)

 2.任意位置添加元素
 l.insert(2,96)   通过索引在任意位置添加元素
 print(l)   注意insert值能将被添加的数据当作列表的一个元素

 3.添加容器类型数据
 l.append(l1)
 l.insert(-1,l1)
 l.extend(l1)   内部原理for循环l1一个个追加到列表的尾部
 l.extend([1,])
 print(l)
list.extend
3、长度
 print(len(l))
4、成员运算in和not in
 print( 444 in l)
5、往列表中添加元素（******）
 append
 insert
 extend

6、删除
 print(l)
 del l[2]   del适用于所有的删除操作
 print(l)

 res1 = l.pop()   尾部弹出
 res2 = l.pop()
 res3 = l.pop()
 print(res1,res2,res3)

 res1 = l.pop(0)   可以指定索引 按照索引弹出元素
 print(res1)

 res = l.remove(33)   指定要删除的元素的值
 print(l)
 print(res)

 s = 'haha'
 print(s)
 del s
 print(s)
7、循环
for i in l:
    print(i)

Python3 支持 int、float、bool、complex（复数）。

在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

像大多数语言一样，数值类型的赋值和计算都是很直观的。

内置的 type() 函数可以用来查询变量所指的对象类型。

在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。

• 1、Python可以同时为多个变量赋值，如a, b = 1, 2。
• 2、一个变量可以通过赋值指向不同类型的对象。
• 3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
• 4、在混合计算时，Python会把整型转换成为浮点数。

# 装饰器 加餐 请问 打印顺序是什么???/

def outter3(fun3):
    print(3)

    def inner(*args,**kwargs):

        print(33)
        res=fun3(*args,**kwargs)
        print(333)
        return res
    return inner

    return inner
def outter2(fun2):
    print(2)

    def inner(*args, **kwargs):
        print(22)
        res = fun2(*args, **kwargs)
        print(222)
        return res
    return inner
def outter1(fun1):
    print(1)
    def inner(*args, **kwargs):
        print(11)
        res = fun1(*args, **kwargs)
        print(111)
        return res
    return inner
@outter3  # out3(ou2)
@outter2  # out2(out1)
@outter1  # out1(ad)
def the_ad():
   print('i am ad')

the_ad()

# 谜题揭晓  123 33 22 11 'I AM AD ' 111 222  333