Python-基本数据类型

基本数据类型
python中变量不需要声明，每个变量使用前必须赋值，变量赋值后该变量才会创建，且在python中变量没有类型，我们所说的类型是变量所指内存中对象的类型

一、可同时为多个变量赋值

a=b=c=1   #从后向前赋值，三个变量都指向同一个内存地址，可为多个对象指定多个变量
a,b,c="haha",2,3
print(a,b,c)

二、.标准数据类型
  不可变数据   Number(数字)、String(字符串)、Tuple(元组)
  可变数据     List(列表)、Set(集合)、Dictionary(字典)

1.Number(数字)  int、float、bool、complex
 a.可使用内置函数type()查看相应变量所指的对象类型，也可以使用isinstance()来判断
   二者区别:type()不会认为子类是一种父类类型,isinstance()会认为子类是一种父类类型。

a=1;  b=1.1;  c=True;  d=2+3j;
print(type(a),type(b),type(c),type(d))
print(isinstance(a,int))
结果:
#<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
#True

b.bool值可以与数字相加

a=True;  b=2+a
print(a,b)
结果:
#True 

 c.当指定一个值时，Number对象就会被创建，可以使用del语句删除一些对象引用

a=3
del a
print(a)
#(报错)NameError: name 'a' is not defined

d.数值运算(+、-、*、/(除法,得到一个浮点数)、//(除法,得到一个整数)、%、**(计算乘方))

a=6;   b=4
print(a/b,end="   ")
print(a//b,end="   ")
print(b**2) #计算b的平方
结果:
#1.5   1   16

e.混合计算时会将整型转换为浮点型
2.String(字符串)

从左往右索引  0     1     2     3    4
             H     e     l     l    o
            -5    -4    -3    -2   -1   从右往左索引

str="Hello";   str1="World"
print(str[-1],end="   ")
print(str[4],end="   ")
print(str[1:3],end="   ")
print(str[-3:-1],end="   ")
print(str*3,end="   ")
print(str+" "+str1)
结果:
#o   o   el   ll   HelloHelloHello   Hello World

3.Tuple(元组)
a.元组写在小括号里，元素之间用逗号隔开，元组中元素类型可以不相同
b.元组可以被索引和切片，从左往右从0开始，从右往左从-1开始
c.元组可以使用'+'进行连接，使用'*'进行重复
d.注意元组中的元素不能修改
e.注意构造包含0或1个元素的元组的特殊语法规则
f.虽然元组的元素不可变，但是它可以包含可变的对象，如list列表

mytuple=(1,"hello",2,4,"world",6)
yourtuple=(20,)     #注意元组中只有一个元素的定义形式
hertuple=()         #注意元组中没有元素的定义形式(空元组)
print(mytuple)
print(mytuple[1:4])
print(mytuple[2])
print(mytuple+yourtuple)
print(mytuple*2)
#mytuple[0]=9       报错:TypeError: 'tuple' object does not support item assignment
    

运行结果:
(1, 'hello', 2, 4, 'world', 6)
('hello', 2, 4)
2
(1, 'hello', 2, 4, 'world', 6, 20)
(1, 'hello', 2, 4, 'world', 6, 1, 'hello', 2, 4, 'world', 6)

4.List(列表)(python中使用最频繁的数据类型)
a.列表中元素的类型可以不相同，支持数字、字符串以及列表
b.列表写在方括号之间，元素之间用逗号隔开
c.列表可以被索引和截取，从左往右从0开始，从右往左从-1开始，列表被截取后返回一个包含所需元素的新列表
d.列表可以使用'+'进行连接，使用'*'进行重复
e.列表中的元素可以改变

mylist=[1,"hello",2,4,"world",6]
yourlist=[20]
print(mylist)
print(mylist[2])
print(mylist[1:4])
print(mylist+yourlist)
print(yourlist*2)
mylist[0]=9
print(mylist)
mylist[1:3]=[2,3]
print(mylist)


运行结果:
[1, 'hello', 2, 4, 'world', 6]
2
['hello', 2, 4]
[1, 'hello', 2, 4, 'world', 6, 20]
[20, 20]
[9, 'hello', 2, 4, 'world', 6]
[9, 2, 3, 4, 'world', 6]

5.Set(集合)
a.无序不重复元素的序列,基本功能是进行成员关系测试和删除重复元素
b.可以使用大括号{}或者set()函数创建集合，但是创建一个空集合必须使用set()函数,{}是用来创建一个空字典
c.创建格式
  myset={value1,value2...}
  myset=set(value)

myset={"hello",1,"world",2,"cool",3}
print(myset)

if "hello" in myset:
   print("hello is in myset")
else:
   print("hello is not in myset")


a = set('abracadabra')
b = set('alacazam')
print(a,b)         #分别打印集合a,b的全部元素
print(a&b)         #取a,b交集
print(a|b)         #取a,b并集
print(a-b)         #取a,b差集
print(a^b)         #取a,b中不同时存在的元素


运行结果:
{1, 'world', 2, 3, 'hello', 'cool'}
hello is in myset
{'b', 'd', 'r', 'c', 'a'} {'m', 'l', 'z', 'c', 'a'}
{'c', 'a'}
{'m', 'b', 'd', 'l', 'r', 'z', 'c', 'a'}
{'r', 'b', 'd'}
{'m', 'r', 'b', 'z', 'd', 'l'}

 

6.Dictionary(字典)(python总有用内置数据类型)
a.字典中的元素是通过键来存取的，而不是通过偏移存取
b.字典用{}标识，是一个无序的键(key):值(value)对集合，其中键（key）必须使用不可变类型，且在同一个字典中键(key)必须是唯一的
c.构造函数dict()可以直接从键值对序列中构建字典     mydict=dict([("hello",1),("world",2),("haha",3)]);  print(mydict)
d.创建空字典使用{}

mydict={}       #定义一个空字典
mydict['one']="haha1"
mydict[2]="haha2"
yourdict={'me':1,'you':2,'his',3,'her',4}
print(mydict['one'],end="   ")
print(mydict[2])
print(yourdict)
print(yourdict.keys())       #打印yourdict字典中的键
print(yourdict.values())     #打印yourdict字典中的值


运行结果:
haha1   haha2
{'me': 1, 'you': 2, 'his': 3, 'her': 4}
dict_keys(['me', 'you', 'his', 'her'])
dict_values([1, 2, 3, 4])

 

三、数据类型之间的转换:只需将数据类型作为函数名即可，下面列举几个进行数据类型之间转换的常用的内置函数
a.  int(x,base)       将一个字符串或数字转换为整型，x为字符串或数字，base为进制数，默认为10，返回整型数据

 int()           #不传入参数时得到结果0
 int(3)          #结果  3
 int(3.6)        #结果  3
 int("12",16)    #结果  18
 int('0xa',16)   #结果  10
 int('10',8)     #结果  8

b.  float(x)          用于将整数和字符串转换为浮点数,返回浮点型数据   

float(1)        #结果  1.0
float(-123.6)   #结果  -123.6
float('123')    #结果  123.0

c.  complex(real,[imag])   
      ** 用于创建一个值为real+imag*j的复数或者转化一个字符串或数为复数。
      **如果第一个参数为字符串，则不需要指定第二个参数，此时字符串参数，需是一个能表示复数的字符串，而且加号或者减号左右不能出现空格。
      **当第一个参数为int或者float时，第二个参数可为空，表示虚部为0；如果提供第二个参数，第二个参数也需为int或者float。
      **参数说明：real(int、long、float或字符串)，imag(int、long、float)

 complex(1,2)      #结果 (1+2j)
 complex(1)        #结果 (1+0j)
 complex("1")      #结果 (1+0j)    当作字符串处理
 complex("1+2j")   #注意此处在'+'两边不能有空格，否则会报错    结果 (1+2j)

d.  str(x)      将对象转换为适于人阅读的形式，返回一个对象的string格式
     

s='hello';  
print(str(s))      #结果   'hello'
s={'hello':'world','my':'girl'};   
print(str(s))    #结果   "{'hello':'world','my':'girl'}"

e.  repr(x)    将对象转化为供解释器读取的形式，返回一个对象的string格式

s='hello';  
print(repr(s))     #结果   "'hello'"
s={'hello':'world','my':'girl'};   
print(repr(s))     #结果     "'hello':'world','my':'girl'}"

f.  eval(x)   用来执行一个字符串表达式，并返回表达式的值

x=7;   
y=eval('3*x');   
print(y)                   #结果   21
print(eval('pow(2,2)'))    #结果   4
print(eval('2+2'))         #结果   4
n=84;    
print(eval('n+4'))         #结果   85

g.  tuple(s)    将列表转换为元组，返回一个元组

list1=['hello','world','my','girl']
tuple1=tuple(list1)
print(tuple1)         #结果    ('hello','world','my','girl')

h.  list(x)    将元组转换为列表,返回一个列表

 mytuple=(1,2,3,4,5,6)
 mylist=list(tuple)
 print(mylist)          #结果  [1,2,3,4,5,6]    
   
 mystr="hello world"
 mylist=list(mystr)
 print(mylist)          #结果  ['h','e','l','l','o',' ','w','o','r','l','d']

i.  set()     创建一个无序不重复元素集，可进行关系测试，删除重复数据，进行并集、交集、差集等，返回新的集合对象

x=set('hello');   
y=set('houhouhou')
print(x,y)
print(x&y)
print(x|y)
print(x-y)

j.  dict()    用于创建一个字典

mydict=dict()
print(mydict)       #结果    {}    空字典