python的入门基础知识

变量

     当为一个值起一个名字的时候，它将会存储在内存中，我们把这块内存称为变量（variable）。变量就是一个名字，通过这个名字，可以找到我们想要的东西。

看个例子:

teacher="小羊"
print(teacher)   
#小羊

变量为啥不叫 " 恒量 " 呢 ? 而叫“变量”？正是因为它是可变的！

看个例子：

x = 3
y = 5
z = x + y
print(z)
# 8

分析：该例子先创建一个变量，名字叫 x ，给它初始化赋值为 3 ，再创建一个变量 y ，并初始化赋值为 5 ；最后创建一个变量 z ，它的值是变量x 和 y 的和。

同样的方法也可以运用到字符串中：

youeat = "烤全羊"
myeat = "烤炉猪"
our = youeat + myeat
print(our)
# 烤全羊烤炉猪

注意：

1. 在使用变量前要先赋值
2. 变量名可以包括字母，数字，下划线，但变量名不可以以数字开头
3. 字母可以是大写或小写，但大写和小写是不同的
4. 等号（=）是赋值的意思，左边是名字，右边是值，不能写反

字符串

如果直接让两个数字相加，那么python会直接将数字相加后的结果告诉你：

5 + 3 

8

但是如果在数字的两边加上引号，就变成了字符串的拼接，这正是引号带来的差别：

"5" + "3" 
"53"

要创建一个字符串时，就要在字符两边加上引号，可以是单引号，也可以是双引号。且必须成对，不能一边用引号，另一边却用双引号

' I LOVR YOU "
# SyntaxError: EOL while scanning string literal

如果字符串内容需要出现单引号或双引号怎么办？

'I LOVR ' YOU'
# SyntaxError: EOL while scanning string literal

向上面这样写，python会误解你的意思（认为' I LOVE ' 是一个字符串，而 YOU' 是里一个不完整的字符串），从而产生错误。

有两种方法来改进，第一种就是使用转义符号 \ 对字符串中的引号进行转义：

'I LOVE\' YOU'

#输出  "I LOVE' YOU"

还有一种就是即使用单引号也使用双引号：

"I LOVE' YOU"
# "I LOVE' YOU"

原始字符串

看起来好像反斜杠是一个好东西，那不妨试试打印 C:\now，代码如下:

>>> string= 'C:\now'
>>> print(string)
C:
OW

打印结果并不是我们预期的，原因是反斜杠 （\）和后边的字符(n)恰好转义之后构成了换行符(\n)。这时候有朋友可能会说，用反斜杠来转义反斜杠不就可以啦。嗯.不错，的确可以用反斜杠对自身进行转义:

>>> string='C:\\now'
>>> print(string)
C:\now

但如果一个字符串中有很多个反斜杠，我们就不乐意了。毕竟，这不仅是一个苦差事，还可能使代码变得混乱。
不过大家也不用怕，因为在 Python 里有一个快捷的方法，就是使用原始字符串。原始字符串的使用非常简单，只需要在字符串前边加一个英文字母r 即可:

>>> string =r ' C: \now '
>>> print(string)
C:\now

在使用字符串时需要注意的一点是:无论是否为原始字符串，都不能以反斜杠作为
结尾(注:反斜杠放在字符串的末尾表示该字符串还没有结束，换行继续的意思，
节会介绍)。如果坚持这样做就会报错:

>>> string ='FishC\'
SyntaxError: EOL while scanning string literal
>>> string = r'FishC\'
SyntaxError: EOL while scanning string literal

大家不妨考虑一下:如果非要在字符串的结尾加个反斜杠，有什么办法可以来灵
实现呢?

长字符串

如果希望得到一个跨越多行的字符串，例如:

从明天起，做一个幸福的人
喂马，劈柴，周游世界
从明天起，关心粮食和蔬菜
我有一所房子，面朝大海，春暖花开
000B恩我
从明天起，和每一个亲人通信
告诉他们我的幸福
那幸福的闪电告诉我的
我将告诉每一个人
给每一条河，每一座山取一个温暖的名字
陌生人，我也为你祝福
愿你有一个灿烂的前程
愿你有情人终成眷属
愿你在尘世获得幸福
我只愿面朝大海，春暖花开

那如果要把这首诗打印出来，用我们学过的知识，就不得不使用多个换行符:

>>> print("从明天起，做一个幸福的人\n 
喂马，劈柴，周游世界\n 
从明天起，关心粮食和蔬菜\n 
我有一所房子，面朝大海，春暖花开\n\n 
从明天起，和每一个亲人通信\n 
告诉他们我的幸福\n 
那幸福的闪电告诉我的\n 
我将告诉每一个人\n\n 
给每一条河，每一座山取一个温暖的名字\n 
陌生人，我也为你祝福\n
愿你有一个灿烂的前程\n 
愿你有情人终成眷属\n 
愿你在尘世获得幸福\n 
我只愿面朝大海，春暖花开\n")

如果行数非常多，就会给我们带来不小的困扰了·.·.··好在 Python 总是设身处地地为我们着想:只需要使用三重引号字符串 (”内容””)就可以轻松解决问题:

>>> rint('''
从明天起，做一个幸福的人
喂马，劈柴，周游世界
从明天起，关心粮食和蔬菜
我有一所房子，面朝大海，春暖花开
从明天起，和每一个亲人通信
告诉他们我的幸福
那幸福的闪电告诉我的
我将告诉每一个人
给每一条河，每一座山取一个温暖的名字
陌生人，我也为你祝福
愿你有一个灿烂的前程
愿你有情人终成眷属
愿你在尘世获得幸福
我只愿面朝大海，春暖花开
''')

最后需要提醒大家的是，编程的时候，时刻要注意 Speak English!初学者最容易犯
的错误(没有之一) 就是误用了中文标点符号。
“眼尖”的你看出来下面代码为什么报错吗?

>>> print (“Please speak english!”)
SyntaxError: invalid character in identifier

是的，该代码中小括号和双引号都使用了中文标点符号，导致 Python 一头雾水，给
出了报错信息。
切记:编程中我们使用的所有标点符号都应该是英文的!

条件分支

if 条件 :
条件为真 (True) 执行的操作
else:
条件为假 (False)执行的操作

写个例子：

if guess == secret:
   print("哎呀，你是小甲鱼心里的蛔虫吗?!“)
   print("哼~猜中了也没有奖励!")
else:
   if quess > secret:
      print("哥，大了大了~~~")
   else:
      print("嘿，小了小了~~~")

分析:当guess和secret 变量的值相等的时候，执行两个 print 语句;否则判断 guess
大还是 secret 大，并显示相应的提示信息。

初识循环

下面介绍Python 的while 循环语法。
while 条件:
条件为真 (True) 执行的操作

非常简单，对吧?Python 向来如此，让我们一起来修改代码吧:
 

temp = input("不妨猜一下小甲鱼现在心里想的是哪个数字:“)
guess = int(temp)

while guess != 8:
   if guess > 8:
      print ("哥，大了大了~~~")
   else:
      print("嘿，小了小了~~~")

   temp = input ("请再试试吧:")
   guess = int(temp)

print("哎呀，你是小甲鱼心里的蛔虫吗?!")

分析: 先接收一次用户的输入，把值转换成整数后赋值给 guess 变量，然后判断该
值是否为正确答案 (8)，如果是就不会执行循环体的内容(因为 while 循环执行的条件
是guess 不等于8); 否则进入循环体，依次判断用户输入的数是大于8还是小于 8，并
分别给出提示信息，最后，要求用户再一次尝试。

Python 的逻辑操作符可以将任意表达式连接在一起，并得到一个布尔类型的值。布
这里给一点提示:可以使用 and 逻辑操作符。
尔类型只有两个值:True和 False，就是真与假。

来看例子:

>>>(3>2)and (1<2)
True
>>>(3>2)and (1> 2)
False

很明显1>2客观上是不存在的,所以这个条件是个伪命题,因此and的结果为 False
使用 and 逻辑操作符将左右两个条件串起来的时候，只有当两者同时成立，结果才能是
True;否则均为 False。大家可以自已多做几次实验来证明。

引入外援

Python 的发明者为了我们可以更快乐地使用好这门语言,在发布 Python 的时候还附带了非常多实用的模块供调用。其中，random 模块就是与生成随机数相关的模块，这个模块里边有一个函数为 randint0，它会返回一个随机的整数:
 

>>>import random
>>> random.randint(1，10)
2
>>> random.randint(1，10)
5
>>> random.randint(1，10)
8

( random：随机；随机的；任意的  )

函数功能

random.randint(参数1, 参数2)
● 参数1，参数2必须是整数
● 函数返回参数1和参数2之间的任意整数

在使用一个外部模块之前，需要先导入。import random 就是将 random 模块导入到
当前文件中。然后调用 random.randint(1,10)函数，随机获取一个1~10 的整数。
可以利用这个函数来进一步改进这个小游戏:

#p32.py
import random

secret =random.randint(1.10)
temp= input("不妨猜一下小甲鱼现在心里想的是哪个数字:")
guess = int(temp)
times=1

while (guess != secret) and (times < 3):
   if quess > secret:
      print("哥，大了大了~~~")
   else:
      print("嘿，小了小了~~~")

   temp = input(请再试试吧:")
   guess = int(temp)
   times= times + 1

if (times <= 3) and (guess == secret):
   print("哎呀，你是小甲鱼心里的蛔虫吗?!)
   print("哼，猜中了也没有奖励噢~")
else:
   print("唔，给三次机会都猜错，不跟你玩了!“)

分析:该代码中,while 语句使用 and 逻辑操作符将两个条件串联起来，只有当 guess
和secret 变量的值不同，并且 times 的值小于3 的时候，才会执行循环体的内容。而只要
其中一个条件不成立，就会果断地退出循环。最后，只需要检查 times 是否小于3，即可
判断用户是猜中了答案还是超过了允许的尝试次数。

闲聊数据类型

所谓闲聊，也称为 gossip，就是一点小事可以聊上半天。下面就来聊一聊 Python 的
数据类型。
在此之前可能已经听说过，Python 的变量是没有类型的。对，没错,Python 的变量看起来更像是名字标签，想贴哪儿就贴哪儿。通过这个标签，就可以轻易找到变量在内存中对应的存放位置。
但这绝不是说 Python 就没有数据类型这回事儿，大家还记得'520'和520 的区别吗?
没错，带了引号的，无论是双引号还是单引号或者是三引号，都是字符串;而不带
引号的，就是数字。字符串相加称为拼接;数字相加就会得到两个数字的和:

>>>'520' + '1314'
'5201314'

>>> 520 + 1314 
1834

下面介绍一些 Python 的数据类型，如整型、浮点型、布尔类型、复数类型等。

整型

整型说白了就是平时所见的整数，Python 3 的整型已经与长整型进行了无缝结合
现在 Python3的整型类似于Java 的 BigInteger 类型，它的长度不受限制，如果说非要有
个限制，那只限于计算机的虚拟内存总数。
所以，使用Python3可以很容易地进行大数运算:
 

>>> 149597870700/ 299792458
499.00478383615643

浮点型

浮点型就是平时所说的小数，例如，圆周率 3.14 就是一个浮点型数据，再例如地球
到太阳的距离约 1.5X10%km，也是一个浮点型数据。Python 区分整型和浮点型的唯一方
式，就是看有没有小数点。
谈到浮点型，就不得不说一下E 记法。E 记法也就是平时所说的科学记数法，用于
表示特别大和特别小的数。打个比方，如果给 Python 提供一个非常极端的数据，那么它
可能会采用 E 记法来表示:
 

>>>a=0.0000000000000000000025
>>> a
2.5e-21

布尔类型

都说“小孩才分对错，大人只看利弊”，其实计算机也有只讲对错的时候。在 Python
中，布尔类型只有 True 和 False 两种情况，也就是英文单词的“对”与“错”。
例如，1+1>3，我们都知道是错的，Python 也知道:

>>>1+1 >3
False
>>>1+1== 2
True

布尔类型事实上是特殊的整型，尽管布尔类型用 True 和False 来表示“真”与“假”
但布尔类型可以当作整数来对待，True 相当于整型值 1，False 相当于整型值0，因此下
面这些运算都是可以的(最后的例子报错是因为 False 相当于0，而0不能作为除数)。

>>> True + True
>>> True*False
0
>>> True / False
Traceback (most recent call last):
File n<pyshell#49>"，line 1，in <module>
True / False
ZeroDivisionError: division by zero

提示:
把布尔类型当成 1和0来参与运算这种做法是不妥的，容易引起代码的混乱
类型转换
接下来介绍几个与数据类型紧密相关的函数:int0、float0和 str0。
int0的作用是将一个字符串或浮点数转换为一个整数:
 

>>>a='520'
>>> b = int(a)
>>> a，b
('520'，520)
>>> c = 5.99
>>> d = int(c)
>>> c，d
(5.99，5)

如果是浮点数转换为整数，Python 会采取“截断”处理，就是把小数点后的数据直接砍掉，而不是四舍五入
float0的作用是将一个字符串或整数转换成一个浮点数(就是小数):

>>>a='520'
>>>b=float(a)
>>> a，b
('520'，520.0)
>>>c=520
>>>d=float(c)
>>>c，d
(520，520.0)

str()的作用是将一个数或任何其他类型转换成一个字符串:

>>>a=5.99
>>>b=str(a)
>>> b
'5.99'
>>>c=str(5e15)
>>> C
'5000000000000000.0'

获得关于类型的信息

有时候可能需要判断一个变量的数据类型，例如，程序需要从用户那里获取一个
数，但用户却输入了一个字符串，就有可能引发一些意想不到的错误或导致程序崩溃
现在告诉大家一个好消息，Python 其实提供了一个函数，可以明确告诉我们变量
类型，这就是 type0函数:

>>> type('520')
<class'str'>
>>> type(5.20)
<class'float'>
>>> type(5e20)
<class'float'>
>>> type(520)
<class 'int'>
>>> type (True)
<class'bool'>

当然，条条大路通罗马，还有别的方法也可以实现同样的效果。
查看 ylhon 的帮助文档，比起 type0函数，更建议使用 isinstance0这个BIF来判断变量的类型。

isinstance0函数有两个参数:                                                                                                      第一个是待确定类型的数据:                                                                                                    第二个是指定一个数据类型。                                                                                                它会根据两个参数返回一个布尔类型的值，True 表示类型一致，False 表示类型不一致。   

 举个例子:
 

>>>a="小甲鱼"
>>> isinstance(a，str)
True
>>> isinstance(520，float)
False
>>> isinstance(520，int)
True

算术操作符

Python 的算术操作符大多数和大家知道的数学运算符一样:
            +   -   *   /    %    **   //
前面四个就不用介绍了，加、减、乘、除，大家都懂。不过下面要介绍的小技巧倒
不是所有人都知道的。
例如，当想对一个变量本身进行算术运算的时候，是不是会觉得写a=a+1或b=
b-3 这类操作符特别麻烦?没错，在 Python 中可以做一些简化:

>>>a=b=c=d=10
>>> a += 1
>>> b -= 3
>>> c *= 10
>>> d /= 8
>>> print(a，b，c，d)
11 7 100 1.25

如果使用过 Python 2.x 版本的读者可能会发现，Python 3 的除法变得有些不同了。
很多编程语言中，整数除法一般都是采用 floor 的方式，有些书籍将其直接翻译为地板除
法。地板除法的概念是:计算结果取比商小的最大整型值(也就是舍弃小数，取整的意
但是在这里我们发现，即使是进行整数间的除法，结果却是返回一个浮点型的精确
数值，也就是 Python 采用真正的除法代替了地板除法。
那有些朋友不乐意了:“萝卜、青菜各有所爱，我就喜欢原来的除法，整数除以整
数就应该得到一个整数!”，于是 Python 的团队也为此想好了办法，就是大家看到的双余
杠，它执行的就是地板除法的操作:

>>>3//2
1
>>>3.0// 2
1.0

注意:
使用地板除法，无论是整型还是浮点型，都将舍弃小数部分

百分号(%) 表示求余数的意思:

>>>5%2
1
>>>4%2
0
>>> 520%14
2

优先级问题

我们规定了运算符的优先级，当多个运算符同时出现在一个表达式的时候，严格按照优先级规定的级别来进行运算。
先乘、除，后加、减，如有括号先运行括号里边的。没错，从小学我们就学到了运算符优先级的精髓，在编程中也是这么继承下来的。
举个例子:

-3*2+5/-2-4
相当于:
(-3)*2+5/(-2)-4

其实多做练习自然就记住了，不用刻意去背。当然，在适当的地方加上括号强调一下优先级，会是更好的方案。
Python 还有一个特殊的乘法，就是双星号(**)，也称为幂运算操作符。   例如 3**2
双星号左侧的3 称为底数，右侧的 2 称为指数，把这样的算式称为3 的2次幂。
在使用 Python 进行幂运算的时候，需要注意的一点是优先级问题。举个例子:

>>> -5 ** 2
-25
>>>5** -2
0.04

从上面的结果可以看出:幂运算操作符比其左侧的一元操作符优先级高，比其右侧
的一元操作符优先级低。

比较操作符

比较运算符包括:
<=    >     >=     ==      I=
比较操作符根据表达式的值的真假返回布尔类型值:

>>> 3<4
True
>>> 1 + 1 >= 2
True
>>>'a' >'b'
False
>>> 5 / 2 <= 3
True
>>> 5> 3 <4
True

逻辑操作符

逻辑操作符包括:
          and      or       not
and 操作符之前已经学习过，在实例中也多次使用。当只有 and 操作符左边的操作
数为 True，且右边的操作符同时为 True 的时候，结果才为 True:

>>>3>4 and 4< 5
False
>>>3<4and 4<5
True

or 操作符与 and 操作符不同，or 操作符只需要左边或者右边任意一边为真，结果都
为真;只有当两边同时为假，结果才为假:

>>>3>4or4<5
True
>>>3>4or4>5
False

not 操作符是一个一元操作符，它的作用是得到一个和操作数相反的布尔类型的值

>>> not True
False
>>> not 0
True
>>>not 4
False

另外，可能还会看到下面这样的表达式:

5>3<4

这在其他编程语言中可能是不合法的，但在 Python 中是行得通的，它事实上被解
释为:
 

5>3and 3<4