python基础|数据类型

1 数字

　　用途:手机号码，不带字母的身份证号码，年龄等

　　定义方式：

age = 18

　　关于数字我们最常见的就是int()。int()可以整形成数字类型，但是在整形字符串时要注意，只能整形纯数字且不带小数点的数字。也可整形有符号数的字符串形式如

print('-1')
-1

　　对于带小数点的数，我们可以用float()，经行整形

print(float('-1.1'))
-1.1

　进制转换

　　在python中不只有十进制数，还有二进制数，八进制数和十六进制数，进制转换是如何实现？

　其他进制转十进制

# 二进制转十进制
10     # 1（2**1）+ 0*（2**1）
# 八进制转十进制
235     # 2*（8**2）+ 3*（8**1）+5*（8**0）
# 十六进制转十进制
217     # 2（18**2）+1（16**1）+7*（16**0）

  十进制转其他进制转

 

# 十进制转二进制
print(bin(10))      # 0b表示二进制

# 十进制转八进制
print(oct(10))      # 0o表示八进制

# 十进制转十六进制
print(hex(10))      # 0x表示十六进制

print(int('1011', 2))    # 二进制转十进制，int可以传一个参数
print(int('11', 8))      # 八进制转十进制
print(int('11', 16))　　　# 十六进制转十进制

2 字符串

　　用途：信息描述

　　定义方式：' ', " ", ''' ''',

　　常用的操作

1，索引取值

practice = 'hello! meKing'
print(practice[1])
e

2 字符串切片（正反切片）：切片区间顾头不顾尾，八大字符串切取一个小的字符串

practice = 'hello! meKing'
print(practice[1:5])    # 从第2到5个。字符串列表都是从0开始计算
ello
print(practice[1:5:1])    #在没有设置步长将默认为1
ello
print(practice[1:8:2])    #在设置步长为2是，从第一个索引值数到第七个，每两个截取一个值
eom
print(practice[1:5:-1])  #从右往左切  
!oll

2 长度len():统计字符个数

practice = 'hello! meKing'
print(len(practice))
13

4 成员运算in 和 not in

print('a'in s)
True
print('a 'not in s)
False

4 去空格strip():默认去除字符串两边的数字

str1 = '  meKing  '
print(str1.strip())    #去除meKing两边的空格
meKing  

str2 = 'meKing'      
print(str2.strip('m'))    #去除两边的‘m'字符
eKing

　　还有rstrip()从右边切 和 lstrip()从左边切。

5 切分split：针对某种分割符的字符串，可以用split切分成列表　

str1 = 'name:meKing:123'
print(str.split(':')
print(a.split(':'))     # 切割顺序是从左往右切的
['name', 'meKing', '123']
print(a.rsplit(':', 1))     # 切割顺序是从左往右切的
['name:meKing', '123']

6 循环

　　支持for循环，将字符串中的内容，一个一个字节送出

str1 = '123456789'
for i in str1:
    print(i,end=' ')
1 2 3 4 5 6 7 8 9 

lower()    #将字符串内地字母小写

upper()     #将字符串的字母大写

startswith()    #判断字符串以什么开始

endswith()    #判断字符串以什么结尾

format()    # 推荐使用的占位符
#第一种 按位置占位
str1 = 'my name is {} me age is {}'.format('meKing', 18)
print(str1)
my name is meKing me age is 18
#第二种按索引占位
str1 = 'my name is {0} me age is {0}'.format('meKing', 18)
print(str1)
my name is meKing me age is meKing
#第三种 指名道姓展位(关键字传参)
name = 'meKing'
age = 18
str1 = 'my name is {} me age is {}'.format(name, age)
print(str1)
my name is meKing me age is 18

join():将序列中中的元素以指定的字符连接生成一个新的字符串
data = 'name:meKing:18'
data1 = data.split(':')
print(data1)
['name', 'meKing', '18']
print(''.join(data1))
namemeKing18

replace():替换

str1= 'name:meKing:18'
print(str1.replace(':', ','))　　#将','替换':'.
name,meKing,18
istigit():判断字符串是不是无符号纯整数，

PS 字符串有三个特点：存一个值：在引号内的数据，对字符串来讲就是一个值

　　　　　　　　　　　有序：字符串中的元素所占的字节，是有序的，可以通过索引查找

　　　　　　　　　　　不可变类型：当字符串中的值改变是，id地址在也会改变

 

 

3 列表

　　用途：可装多个元素，字符串，数字，都可以

　　定义方式：将元素放入'[]'内，用','隔开.

　　常用操作

1 取值：按索引取值

 

list1 = [1, 2, 'a', 'b']
print（list1[3])
a

 2 切片,在切片区间顾头不顾尾

list1 = [1, 2, 'a', 'b']
print(list1[0:3])   #切片区间(0 3) 
[1, 2, 'a']
print(list1[0:3:2]) #切片区间(0 3),步长为2，每两个切一下
[1, 'a']
print(list1[4:1:-1])    #反向切片
['b', 'a']

3 长度len(),计数列表元素个数或列表长度

list1 = [1, 2, 'a', 'b']
print(len(list1))

 

4 成员运算in 和 not in

list1 = [1, 2, 'a', 'b']
print(1 in list1)
Ture
print(1 not in list1)
False

 

5 追加

l = [1, 2, 'a', 'b']
l1 = [1, 2, 3, 4]
l.append(l1)    # 尾部添加
print(l)
[1, 2, 'a', 'b', [1, 2, 3, 4]]

l.insert(-1,l1)    指定位置添加
print(l)
[1, 2, 'a', [1, 2, 3, 4], 'b']

l.extend(l1)  # 将l1列表内的元素一个一个尾部添加l列表中
print(l)
[1, 2, 'a', 'b', 1, 2, 3, 4]

 

6 删除

del+对象 #永久删除，其中数据
l = [1, 2, 'a', 'b']
a = l.pop(2)    # 按照索引值删除,并且可以将删除值提出来使用
print(l)
print(a)
[1, 2, 'b']
b

 

7 循环

　支持for循环，将以将列表元素遍历。

列表list()内置方法
  

 l = [a, b, c]
 l.count(指定元素)     #计算列表指定元素的个数
 l.clear(),                # 清除列表元素
 l.reverse()             # 反转列表
 l.sort()                  # 默认从小到大排序    

　　列表的特性  

  　　　　　　1，存多个值
                        2，有序的
                        3，可变
  队列：先进先出

　　先进去的元素先出来，如同排队买票，先排队的在前面先买票。
  堆栈：先进后出

　　先进去的元素后出来，如同子弹夹一样，先进去的后最后打出来。

python中也有堆栈和队列

# 队列：先进先出
l = [ ]
# 入队
l.append('1')
l.append('2')
l.append('3')
# 出队
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))
# 堆栈：先进去后出来
print(l.pop())
print(l.pop())
print(l.pop())

 

 4 元组tupe()

  　　元组能存多个值，元素间用逗号隔开，不能被替换

t = (5, 4, 3, 4, 5)
# 元组取值 ，可以按索引取值但不能修改
print(t[1])
4
# 切片 顾头不顾尾
print(t[:2:1]）
（5， 4， 3）
# 3 长度成员运算
print(len(t))
5
# 循环  支持for循环
for i in t:
    print(i, end='')
54345
t.count(5) # 计数次数
2
t.index(5) # 查索引坐标
0

　　元组的特性：1，能存多个值    2， 不可变类型     3 ，支持循环

 4 字典dict()

  作用：能存储多个值，值是key：value键值对，用逗号隔开
 　　　　

 dic = {'a':1, 'b':2, 'c':3}

 

  当键key重复时，重复只会用最后一个键值对。所以字典的key不能重复，唯一标识新数据
  存取：字典按key值存取

dic = {'a':1, 'b':2, 'c':3}
print(dic['a']）
1
dic[1] = 1
print(dic)　　　　# 当key值不存在时，会新增一个键值对
{'a':1, 'b':2, 'c':3, 1:1}
# 成员运算in 和 not in 成员运算是判断键key,不判断value
print('b' in t)
True
print(2 in t)
False 

 

  4，删除

  del dic[]  #按key删除
  dic.pop('key') # 删除value
  dic.cler()  # 清除字典元素，得到一个空列表

 

  定义字典的三种方式
  

  第一种
  dic = {'a':1, 'b':2, 'c':3}
  第二种
  dic = dict(a = 1, b = 2, c = 3)
  第三种
  l = [[a,1],[b,2],[c,3]]
  dic1 = dict(l)

　　内置方法

  dic.key()     　　# 取字典中所有key值，是列表
  dic.value()      # 取字典中所有value，是列表
  !!! dic.get() 　　# 取值，没有时候返回None
  dic.fromkeys()   # 创造字典
  dic.popitem()    # 尾部弹出元组类型键值对
  dic.setdefault(key,value)  # 健存在，返回原来值，键不在创建一个键值对
  dic.update() 　　# 更新字典

　　

 5 集合set()

 　　集合存多个不重复的值  每个元素必须是不可变类型且无序。集合在做大量数据之间的关系运算，去重等非常方便
        做关系运算

　　

a = {i for i in range(10) }
a1 = {i for i in range(5,15)}

print(a & a1) # 集合a和a1的交际 print(a | a1) # 集合a和a1的并集 print(a1 - a) # 集合a1中不和a重合的元素 print(a ^ a1) # 集合a和a1且不重合的元素
# 父集和子集

a2 = {1, 2, 3}

print(a >= a2 )　　# a是a2的父集 如果
Ture
{5, 6, 7, 8, 9}
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
{10, 11, 12, 13, 14}
{0, 1, 2, 3, 4, 10, 11, 12, 13, 14}
# 添加元素
print（a2.add(4))
{1, 2, 3, 4}
# 删除元素
print(a2.remove(1)）
{2, 3, 4}
print(a2.discard(1))　　　　# remove删除没有的元素报错，而discard不会报错
{3, 4}

有奖竞猜

 　　set1 = {}   

　　print(type(set1)　　　　# 结果是一个什么类型

 

         t = (1)  

　　print(type(t))　　　　　# 结果是一个什么类型

　　tupe1 = ()

　　print(tupe1)　　　　　# 结果是一个什么类型
      总结 容器类型，只要有一个元素都要加逗号

转载于:https://www.cnblogs.com/huaiXin/p/11128190.html