Python基础一（基本类型和运算符）

在说Python的基本类型钱我们先说下Python注释方式有哪几

Python注释

行注释
#行注释行注释用以#开头，#右边的所有文字当做说明，而不是真正要执行的程序，起辅助说明作用

# 我是注释，可以在里写一些功能说明之类的哦

print('hello world')

块注释
'''块注释'''或者"""快注释""" 块注释用三个单引号或者三个双引号包围，引号中的文字当做说明，而不是真正要执行的程序，起辅助说明作用

'''我是多行注释，可以写很多很多行的功能说明

'''

"""

我是块注释，可以在里写一些功能说明之类的哦

"""

print('hello world')

python程序中，中文支持

在Python2中如果直接在程序中用到了中文，比如

print('你好')

如果直接运行输出，程序会出错.

如何避免呢：

在程序的开头设置编码格式就不会报错了

#coding=utf-8

或者

# -*- coding:utf-8 -*-

建议使用第二种格式

在Python3中则不会出错

变量的定义

变量：在程序执行的过程中，在某个范围内其值可以发生改变的量

注：

python是弱类型的语言所以定义时不需要定义变量类型（java时强类型语言，定义时需要定义变量类型）

python中变量的定义格式

变量=值

例子：

counter = 100          # 整型变量

miles   = 1000.0       # 浮点型变量

name    = "runoob"     # 字符串

#多个变量赋值

#Python允许你同时为多个变量赋值。例如：

a = b = c = 1

#或者

a, b, c = 1, 2, "runoob"

#两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c

变量的类型

在python中，只要定义了一个变量，而且它有数据，那么它的类型就已经确定了，不需要我们开发者主动的去说明它的类型，系统会自动辨别
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
可以使用type(变量的名字)，来查看变量的类型

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

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

Number（数字）

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

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

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

　　

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

　　此外还可以用 isinstance 来判断：

a = 111

isinstance(a, int) #True

isinstance 和 type 的区别在于

type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。

class A:

    pass

class B(A):

    pass

isinstance(A(), A)  # returns True

type(A()) == A      # returns True

isinstance(B(), A)    # returns True

type(B()) == A        # returns False

注意：

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

　　当你指定一个值时，Number 对象就会被创建：

del语句

var1 = 1

var2 = 10

　　您也可以使用del语句删除一些对象引用。

　　del语句的语法是：

del var1[,var2[,var3[....,varN]]]]

　　您可以通过使用del语句删除单个或多个对象。例如：

del var

del var_a, var_b

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

RunoobRunoob

RunoobTEST

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

>>> print('Ru\noob')

Ru

oob

>>> print(r'Ru\noob')

Ru\noob

　　另外，反斜杠()可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。

　　注意:Python 没有单独的字符类型，一个字符就是长度为1的字符串。

实例

>>>word = 'Python'

>>> print(word[0], word[5])

P n

>>> print(word[-1], word[-6])

n P

　　与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。

注意：

反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
字符串可以用+运算符连接在一起，用*运算符重复。
Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
Python中的字符串不能改变。

List（列表）

　　List（列表）是 Python 中使用最频繁的数据类型。

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

　　列表是写在方括号([])之间、用逗号分隔开的元素列表。

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

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

变量[头下标:尾下标]

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

　　加号（+）是列表连接运算符，星号（*）是重复操作。

如下实例：

#!/usr/bin/python3

list = [ 'abcd', 786 , 2.23, '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', 786, 2.23, 'runoob', 70.2]

abcd

[786, 2.23]

[2.23, 'runoob', 70.2]

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

['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

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

实例

>>>a = [1, 2, 3, 4, 5, 6]

>>> a[0] = 9

>>> a[2:5] = [13, 14, 15]

>>> a

[9, 2, 13, 14, 15, 6]

>>> a[2:5] = []   # 将对应的元素值设置为 []

>>> a

[9, 2, 6]

List内置了有很多方法，例如append()、pop()等等，这在后面会讲到。

注意：

List写在方括号之间，元素用逗号隔开。
和字符串一样，list可以被索引和切片。
List可以使用+操作符进行拼接。
List中的元素是可以改变的。

Tuple（元组）

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

元组中的元素类型也可以不相同：

实例

#python3

tuple = ( 'abcd', 786 , 2.23, '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', 786, 2.23, 'runoob', 70.2)

abcd

(786, 2.23)

(2.23, 'runoob', 70.2)

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

('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

　　元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。其实，可以把字符串看作一种特殊的元组。

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

>>> print(tup[0])

1

>>> print(tup[1:5])

(2, 3, 4, 5)

>>> tup[0] = 11  # 修改元组元素的操作是非法的

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: 'tuple' object does not support item assignment

>>>

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

　　构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组

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

　　string、list和tuple都属于sequence（序列）。

注意：

与字符串一样，元组的元素不能修改。
元组也可以被索引和切片，方法一样。
注意构造包含0或1个元素的元组的特殊语法规则。
元组也可以使用+操作符进行拼接。

Set（集合）

　　集合（set）是一个无序不重复元素的序列。

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

　　可以使用大括号 { } 或者 set() 函数创建集合

　　注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

parame = {value01,value02,...}

或者

set(value)

实例

#python3

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中不同时存在的元素

以上实例输出结果：

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

Rose 在集合中

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

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

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

{'a', 'c'}

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

Dictionary（字典）

　　字典（dictionary）是Python中另一个非常有用的内置数据类型。

　　列表是有序的对象结合，字典是无序的对象集合。

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

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

键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。

实例

#python3

dict = {}

dict['one'] = "1 - 菜鸟"

dict[2]     = "2 - 菜鸟"

tinydict = {'name': 'runoob','code':1, 'site': 'www'}

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

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

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

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

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

以上实例输出结果：

1 - 菜鸟

2 - 菜鸟

{'name': 'runoob', 'site': 'www', 'code': 1}

dict_keys(['name', 'site', 'code'])

dict_values(['runoob', 'www', 1])

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

实例

>>>dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])

{'Taobao': 3, 'Runoob': 1, 'Google': 2}

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

{2: 4, 4: 16, 6: 36}

>>> dict(Runoob=1, Google=2, Taobao=3)

{'Taobao': 3, 'Runoob': 1, 'Google': 2}

另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。

注意：

字典是一种映射类型，它的元素是键值对。
字典的关键字必须为不可变类型，且不能重复。
创建空字典使用 { }。

数据类型转换

　　有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

　　以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

函数	描述
int(x [,base ])	将x转换为一个整数
long(x [,base ])	将x转换为一个长整数
float(x )	将x转换到一个浮点数
complex(real [,imag ])	创建一个复数
str(x )	将对象 x 转换为字符串
repr(x )	将对象 x 转换为表达式字符串
eval(str )	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s )	将序列 s 转换为一个元组
list(s )	将序列 s 转换为一个列表
chr(x )	将一个整数转换为一个字符
unichr(x )	将一个整数转换为Unicode字符
ord(x )	将一个字符转换为它的整数值
hex(x )	将一个整数转换为一个十六进制字符串
oct(x )	将一个整数转换为一个八进制字符串

运算符

算术运算符

下面以a=10 ,b=20为例进行计算

运算符	描述	实例
+	加	两个对象相加 a + b 输出结果 30
-	减	得到负数或是一个数减去另一个数 a - b 输出结果 -10
*	乘	两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/	除	x除以y b / a 输出结果 2
//	取整除	返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
%	取余	返回除法的余数 b % a 输出结果 0
**	幂	返回x的y次幂 a**b 为10的20次方，输出结果 100000000000000000000

赋值运算符

运算符	描述	实例
=	赋值运算符	把=号右边的结果给左边的变量 num=1+2*3 结果num的值为7

复合赋值运算符

运算符	描述	实例
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c = a 等效于 c = c a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c ✲✲ = a 等效于 c = c ✲✲ a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

比较(即关系)运算符

python中的比较运算符如下表

运算符	描述	示例
==	检查两个操作数的值是否相等，如果是则条件变为真。	如a=3,b=3则（a == b) 为 true.
!=	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	如a=1,b=3则(a != b) 为 true.
<>	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	如a=1,b=3则(a <> b) 为 true。这个类似于 != 运算符
>	检查左操作数的值是否大于右操作数的值，如果是，则条件成立。	如a=7,b=3则(a > b) 为 true.
<	检查左操作数的值是否小于右操作数的值，如果是，则条件成立。	如a=7,b=3则(a < b) 为 false.
>=	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。	如a=3,b=3则(a >= b) 为 true.
<=	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。	如a=3,b=3则(a <= b) 为 true.

逻辑运算符

|运算符 |逻辑表达式| 描述 |实例

|-----|-----|-----|

|and| |x and y| 布尔"与"
- 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。| (a and b) 返回 20。

|or| |x or y| 布尔"或"
- 如果 x 是 True，它返回 True，否则它返回 y 的计算值。| (a or b) 返回 10。

|not| |not x| 布尔"非"
- 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。| not(a and b) 返回 False

标识符

　　开发人员在程序中自定义的一些符号和名称

　　标示符是自己定义的,如变量名、函数名等

标示符的规则

标示符由字母、下划线和数字组成，且数字不能开头
python中的标识符是区分大小写的

命名规则

见名知意：起一个有意义的名字，尽量做到看一眼就知道是什么意思(提高代码可读性)
驼峰命名法
小驼峰式命名法（lower camel case）：第一个单词以小写字母开始；第二个单词的首字母大写，例如：myName、aDog
大驼峰式命名法（upper camel case）：每一个单字的首字母都采用大写字母，例如：FirstName、LastName
不过在程序员中还有一种命名法比较流行，就是用下划线“_”来连接所有的单词，比如send_buf

关键字

python一些具有特殊功能的标示符，这就是所谓的关键字

关键字，是python已经使用的了，所以不允许开发者自己定义和关键字相同的名字的标示符

	  and     as      assert     break     class      continue    def     del

      elif    else    except     exec      finally    for         from    global

      if      in      import     is        lambda     not         or      pass

      print   raise   return     try       while      with        yield

后面我会讲一下关键字的常见用法。