python语法基础（基本数据类型）

一、变量赋值

1.python中的变量不需要声明，每个变量在使用前必须赋值，该变量赋值以后被创建。

一个变量通过赋值指向不同的类型。

2.允许多个变量同时赋值，也可以为多个变量指定多个对象。

二、标准数据类型

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

1.Number（数字）

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

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

用isinstance来判断：

<1>isinstance 和 type() 函数可以用来查询变量所指的对象类型。在判断继承关系时两者有区别区别：

(1) type()不会认为子类是一个父类类型.

（2）isinstance()会认为子类是一个父类类型.

class A:
    pass
class B(A):
    pass

isinstance(A(),A)
True
type(A())==A
True

isinstance(B(),A)
True

type(B())==A
False

类似is和==的区别：

is是指向判断的对象所在的地址是否相同，==判断value值是否相同。

isinstance(变量名，类型)：判断该变量是否是该类型，或者是否是该类和该类的父类类型

type(变量名)：获取该变量名的类型,结合==判断该变量的类型是否等于目标类型(等号右边value值)。

<2> 创建Number对象：当指定一个值时，Number对象被创建

删除：del ,通过使用del语句删除单个或多个对象

x=1

y=2

print(x)
1

del(x)

print(x)
Traceback (most recent call last):

  File "<ipython-input-45-fc17d851ef81>", line 1, in <module>
    print(x)

NameError: name 'x' is not defined

x=5

y=6

print(x,y)
5 6

del x,y

print(x,y)
Traceback (most recent call last):

  File "<ipython-input-55-b9cd30493a4c>", line 1, in <module>
    print(x,y)

NameError: name 'x' is not defined

<3>数值运算：

2/4   #除法，得到一个浮点数
Out[56]: 0.5

2//4  #除法，得到一个整数
Out[57]: 0

2**5  #乘方
Out[58]: 32

2.List(列表）

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

t=['a','b','c','d','e','f','g']

（2）和字符串一样，List可以被索引和切片。从左往右下标从0开始，从右往左下标从-1开始。

（3）List可以用+进行拼接，*是重复操作。

 t1=['a','b','c']
 print(t+t1)
 ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'c']

print(t*2)
['a', 'b', 'c', 'd', 'e', 'a', 'b', 'c', 'd', 'e']

（4）List中的元素是可以改变的，Python中的字符串不能改变。

t[0]=1
print(t)
[1, 'b', 'c', 'd', 'e'] 

t2='abcdefg'

t2[0]=1
Traceback (most recent call last):

  File "<ipython-input-89-5dfc673da11f>", line 1, in <module>
    t2[0]=1

（5）Python 列表截取可以接收第三个参数，参数作用是截取的步长。

t[1:4:1]
['b', 'c', 'd']

t[1:4:2]
['b', 'd'] 

如果第三个参数为负数表示逆向读取

t[2: :-1]
['c', 'b', 'a']

 t[1: :-1]
 ['b', 'a']

（6）列表中的元素类型可以不同

t=[1,2,'3',2.2]

print(t)
[1, 2, '3', 2.2]

3.Tuple(元组）

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

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

print(s1[0])
1

print(s1[3])
4

s1[0]=13
Traceback (most recent call last):

  File "<ipython-input-104-5d738ff0c428>", line 1, in <module>
    s1[0]=13

TypeError: 'tuple' object does not support item assignment

（2）元祖中的元素类型可以不同

 s2=(1,2,'abcd',13.14,'hello')

（3）元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取。其实，可以把字符串看作一种特殊的元组。可以被索引和切片。

s2[2:]
Out[107]: ('abcd', 13.14, 'hello')

s2[1:4:2]
Out[108]: (2, 13.14)

s2[2: :-1]
Out[109]: ('abcd', 2, 1)

s2[2:4:-1]    #第三个元素为负数，代表逆向输出，第二个元素不能写
Out[110]: ()

（4）元组也可以使用+操作符进行拼接。

（5）虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表，List列表中的元素可以改变。

tuple_a = (1,[1,2,3])
print(tuple_a)
(1, [1, 2, 3])

tuple_a[1][0]='a'

print(tuple_a)
(1, ['a', 2, 3])

6.创建空元组：

s=()#创建空元祖

print(s)
()

创建包含一个元素的元组，需要在元素后面添加逗号来消除歧义

s2=(20,) #一个元素需要在后面添加逗号

4.Set集合

（1）集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

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

（3）可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() ， { } 是用来创建一个空字典

ss={1,2,3,4,5}

print(ss)
{1, 2, 3, 4, 5}

ss=(1,2,3)

print(ss)
(1, 2, 3)

set()   #只能用（）创建空集合
Out[134]: set()  

set{}
  File "<ipython-input-135-bcdbceb6c654>", line 1
    set{}
       ^
SyntaxError: invalid syntax

（4）Set集合中，重复的元素会被自动去掉。

ss={1,111111,1,1,1}

print(ss)
{1, 111111}

（5）Set中成员测试

set={'abc','bcd','google','baidu','abc','zhihu'}
print(set)

#成员测试
if 'abc' in set:
    print('abc在set集合中')
else:
    print('abc不在set集合中') 

（6）set中的集合运算

a = set('abracadabra')
b = set('alacazam')

 a = set('abracadabra')
b = set('alacazam')

print(a-b)  #差集
{'d', 'r', 'b'}

print(a|b)  #并集
{'a', 'm', 'd', 'l', 'c', 'r', 'z', 'b'}

print(a&b)  #交集
{'a', 'c'}

print(a^b)  #a与b中不同时存在的元素
{'r', 'z', 'm', 'd', 'l', 'b'}

5.Dictionary（字典）

（1）列表是有序的对象集合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

（2）字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。它的元素是键值对。

d={'name':'zhangchen','wendu':'35.6','riqi':'10.12'}

print(d)
{'name': 'zhangchen', 'wendu': '35.6', 'riqi': '10.12'}

 print(d.keys())  #输出所有键
dict_keys(['name', 'wendu', 'riqi'])

print(d.values())  #输出所有值
dict_values(['zhangchen', '35.6', '10.12'])

（3）键(key)必须使用不可变类型，且不能重复。在同一个字典中，键(key)必须是唯一的。

（4）创建空字典使用{ }。dict={}

（5）构造函数 dict() 可以直接从键值对序列中构建字典：

dict([('R', 1), ('G', 2), ('T', 3)])
Out[166]: {'R': 1, 'G': 2, 'T': 3}

dict(Ru=1, Go=2, Ta=3)
Out[167]: {'Ru': 1, 'Go': 2, 'Ta': 3}

{x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

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

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

本文地址：https://blog.csdn.net/zhangxue1232/article/details/109028577