\#Python3基本数据类型

'''

Python 中的变量不需要声明，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建

在Python中，变量就是变量，它没有类型，我们所说的类型是变量所指的内存找那个对象的类型。

等号(=) 用来给变量赋值

等号(=) 运算符左边是一个变量名，等号(=)运算符右边是存储在变量中的值

'''

counter = 100;

miles = 1000.0;

name  = "runoob"

print(counter);  \#整型变量

print(miles); \# 浮点型变量

print(name);  \# 字符串

'''

标准数据类型

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

Number(数字)

String(字符串)

List(列表)

Tuple(元组)

Sets(集合)

Dictionary(字典)

'''

\#Number(数字)

'''

Python3支持int float bool complex(复数)

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

'''

a,b,c,d = 20, 5.5 ,True, 4+3j

print(type(a),type(b),type(c),type(d),)

\#还可以用isinstance来判断数据类型

class A:

pass

class B(A):

pass

print(isinstance(A(), A)) \#return True

print(type(A()) == A)  \#return True

print(isinstance(B(), A)) \#return True

print(type(B()) == A)  \#return False

\#区别：

\#type()不会认为子类是一种父类类型

\#isinstance()会认为子类是一种父类类型

'''

Python2 中没有布尔型的，它用数字0表示False，用1表示True。到Python3中，把True和False定义成

关键字，但他们的值还是1和0，他们可以和数字相加

'''

var1 =1;

var2 = 2

\#可以使用del语句删除一些对象引用

\#语法

del var1,var2;\#删除var1 变量

\#数值运算

print(5+4); \#加法

\#9

print(4.3 - 2); \#减法

\#2.3

print(3 \*  7); \#乘法

\#21

print(2 / 4); \#除法，得到一个浮点数

\#0.5

print(2 // 4); \#除法，得到一个整数

\#0

print(17 % 3); \#取余

\#2

print(2 \*\* 5); \#乘方

\#32

'''

1、Python可以同时为多个变量赋值，如a,b = 1.2

2、一个变量可以通过赋值只想不同类型的对象

3、数值的除法(/)总是返回一个浮点数，要获取整数使用//操作符

4、在混合计算时，Pyhong会把整型转换成为浮点数

'''

print("------------------------String--------------------------")

\#String( 字符串)

'''

Python中的字符串用单引号或双引号括起来，同时使用反斜杠转义特殊字符。

字符串的截取的语法格式如下：

变量\[头下标：尾下标\]

索引值以0为开始值，-1位从末尾的开始位置

加好(+)是字符串的连接符，星号(\*)表示复制当前字符串，紧跟的数字为复制的次数。

'''

str = 'Runoob'

print(str)  \# 输出字符串

print(str\[0:-1\])\# 输出第一个到倒数第二个的所有字符

print(str\[0\])\#输出字符串第一个字符

print(str\[2:5\])\#输出从第三个开始到第五个的字符

print(str\[2:\])\#输出从第三个开始的后的所有字符

print(str \* 2)\#输出字符串两次

print(str + "TEST")\#连接字符串

'''

执行结果：

Runoob

Runoo

R

noo

noob

RunoobRunoo

RunoobTEST

'''

\#Python使用反斜杠(\\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

word = "Python"

print(word\[0\],word\[5\]);

print(word\[-1\],word\[-6\]);

\#Python字符串是不能被改变的。向一个所以位置复制，比如word\[0\] ='m' 会导致错误

'''

使用注意：

反斜杠可以用来转义，使用r可以让反斜杠不发生转义

字符串可以用+运算符连接在一起，用\*运算符重复。

Python中的字符串有两种引用方式，从左往右以0开始，从有往左以-1开始

Python中的字符串不能改变

'''

print("------------------------List--------------------------")

\#List(列表)

'''

List(列表)是Python中使用最频繁的数据类型

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，他支持数字，字符串甚至可以包含列表(所谓嵌套)

列表是写在方括号之间，用都好分隔开的元素列表

和字符串一样，列表同样可以被索引和截取，列表被截取后返回个包含所需元素的列表

列表截取的语法格式如下：

变量\[头下标，尾下标\]

所以值以0为开始值，-1为从末尾的开始位置

加好是列表连接运算符，星号是重复操作

'''

list = \['abcd',768,2.32,'runoob',70.2\]

tinylist =\[123,'runoob'\]

print(list);

print(list\[0\]);

print(list\[1:3\]);

print(list\[2:\]);

print(tinylist \* 2);

print(list + tinylist);

\#输出结果：

'''

\['abcd', 768, 2.32, 'runoob', 70.2\]

abcd

\[768, 2.32\]

\[2.32, 'runoob', 70.2\]

\[123, 'runoob', 123, 'runoob'\]

\['abcd', 768, 2.32, 'runoob', 70.2, 123, 'runoob'\]

'''

\#与Python字符串不一样的是，列表中的元素是可以被改变的：

\#List内置了很多方法，例如append()、pop()等等

'''

注意：

List写在方括号之间，元素用逗号隔开

和字符串一样，list可以被索引和切片

List可以使用+操作符进行拼接

List中的元素是可以改变的

'''

print("------------------------Tuple(元组)--------------------------")

\#元组(tuple)与列表类似，不同之处在于元组的元素不能修改。元组写在小括号里，元素之间用逗号隔开。

tuple =('abcd', 768, 2.32, 'runoob', 70.2)

tinytuple =(123,'runoob');

print(tuple);

print(tuple\[0\]);

print(tuple\[1:3\]);

print(tuple\[2:\]);

print(tinytuple \* 2);

print(tuple + tinytuple);

\#输出结果:

'''

('abcd', 768, 2.32, 'runoob', 70.2)

abcd

(768, 2.32)

(2.32, 'runoob', 70.2)

(123, 'runoob', 123, 'runoob')

('abcd', 768, 2.32, 'runoob', 70.2, 123, 'runoob')

'''

\#元组与字符串类似，可以被索引且下标索引从0 开始， -1为从末尾开始的位置。也可以进行截取。

tup = (1,2,3,4,5,6)

print(tup\[0:3\]);

print(tup\[0:-1\]);

\#string 、 list 和tuple都属于sequence(序列)

'''

与字符串一样，元组的元素不能修改。

元组也可以被索引和切片，方法一样

注意构造包含0或1个元素的元组的特殊语法规则

元组也可以使用+操作符进行拼接

'''

print("------------------------Tuple(元组)--------------------------")

'''

集合(set)是一个无序不重复元素的序列

基本功能是进行成员关系测试和删除重复元素

可以使用大括号\{ \}或者set()函数创建集合，注意：创建一个空集合必须用set()而不是\{\},因为\{\}是用来创建一个空字典

'''

\#创建格式：

student = \{'Tom','Jim','Mary','Tom','Jack','Rose'\}

print (student) \#输出集合，重复的元素被自动去掉

if('Rose' in student):

print('Rose 在集合中')

else:

print('Rose 不在集合中')

\#set可以进行集合运算

a = set('abracadabra');

b = set('alacazam');

print(a);

print(a - b);\# a和b的差集

print(a | b);\# a和b的并集

print(a & b);\# a和b的交集

print(a ^ b);\# a和b中不同时存在的元素

\#输出结果：

'''

\{'Rose', 'Mary', 'Jim', 'Jack', 'Tom'\}

Rose 在集合中

\{'d', 'r', 'c', 'a', 'b'\}

\{'b', 'd', 'r'\}

\{'d', 'r', 'm', 'z', 'a', 'c', 'l', 'b'\}

\{'a', 'c'\}

\{'m', 'd', 'r', 'l', 'z', 'b'\}

'''

print("------------------------Dictionary(字典)--------------------------")

'''

字典(Dictionary) 是Python中另一个非常有用的内置数据类型

列表是有序的对象结合，字段是无序的对象结合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字段是一种映射类型，字典用"\{\}"标识，它是一个无序的键(key):值(value)对集合

键(key)必须使用不可变类型。

在同一个字段中，键(key)必须是唯一的。

'''

dict = \{\}

dict\['one'\] = "1 - test1";

dict \[ 2 \] = '2 - test2';

tinydict = \{'name':'runoob','code':1,'site':'www.runoob.com'\};

print(dict\['one'\]); \# 输出键为 'one' 的值

print(dict\[2\]); \# 输出键为 2 的值

print(tinydict); \# 输出完整的字典

print(tinydict.keys()); \# 输出所有键

print(tinydict.values()); \# 输出所有值

\#输出结果：

'''

1 - test1

2 - test2

\{'name': 'runoob', 'code': 1, 'site': 'www.r

dict\_keys(\['name', 'code', 'site'\])

dict\_values(\['runoob', 1, 'www.runoob.com'\])

'''

\#字典类型也有一些内置的函数，例如clear(),keys(),value()

'''

字典是一种映射类型，他的元素是键值对

字典的关键字必须为不可变类型，且不能重复

创建空字典使用\{\}。

'''

print("------------------------Python数据类型转换--------------------------")

'''

int(x\[.base\]): 将x转换为一个整数

float(x):将x转换到一个浮点数

complex(rel\[.imag\])：创建一个复数

str(x):将对象x转换为字符串

repr(x):将对象x转换为表达式字符串

eval(str)：用来计算在字符串中的有效Python表达式，并返回一个对象

tuple(s):将序列s转换为一个元组

list(s)：将序列s转换为一个列表

set(s)：转换为可变集合

dict(d):创建一个字典。d必须是一个序列(key,value)元组

frozenset(s)：转换为不可变集合

chr(x)：将一个整数转换为一个字符

ord(x)：将一个字符转换为它的整数值

hex(x)：将一个整数转换为一个十六进制字符串

oct(x)：将一个整数转换为一个八进制字符串

'''