Python基础总结

Python解释器：

1、官方CPython

C语言开发，最广泛的Python解释器

2、IPython

一个交互式、功能增强的Cpython

3、PyPy

Python语言写的Python解释器，JIT技术，动态编码

JIT技术，动态编码

4、Jython

Python的源代码变成Java的字节码，跑在JVM上

5、IronPython

与Jython类似，运行在.Net平台上的解释器，Python代码被编译成.Net的字节码

# Python基础语法

注释 #

 

数字

整数，不区分long（长整数）和int（整数）

进制0XA,0O10,0B10

bool,2个值True、False

int：（符号整数）通常被称为是整数或整数，没有小数点的正数或负数

long：（长整数）或渴望，无限大小的整数，这样写整数和一个大写或小写的L

 

Python允许你使用长L的小写，但建议您只使用一个大写字母L，以避免与数字1混淆。python长整数显示一个大写字母L。

 

浮点数

1.2、3.1415、-0.12、1.46e9等价于1.46*10*9

float:(浮点实际值)彩车，代表实数，小数除以整数部分和小数部分的书面。花车也可能是在科学记数法与E或指示的10次方（2.5e2 = 2.5 x 10*2 = 250）

 

 

复数，1+2j

complex:(复数)+BJ的形式，其中a、b是彩车和J（或j）表示-1的平方根（这是一个虚数）。a是真正的数字部分，b是虚部。复数不使用Python编程。

 

一个复杂的数字组成的有序对一个真正的浮点数字+ BJ，其中a是实部和b是复数的虚部表示

 

 

字符串

1、使用'”单双引号引用的字符的序列

2、”’ “””单双三引号，可以跨行，可以在其中自由的使用单双引号

3、在字符串前面加上R或者r前缀，表示该字符串不做特殊处理

 

数字转换类型

Python的数字转换内部包含一个共同的评价类型的混合型的表达。但有时，你需要明确强迫一个数字从一个类型到另一个运算符或函数的参数，以满足要求。

 

int类型（X）转换X到一个普通整数。

long（X）转换X到一个长整数。

float类型（X）转换X到浮点数字。

complex （x）的转换与真正的第X部和虚部为零的x到一个复杂的数量。 类型复杂（X，Y）转换x和y的第X部和虚部Ÿ复数。 x和y是数值表达式 内置数功能

 

数值类型实例：

int        long                      float             complex

10        51924361L                      0.0               3.14j

100      -0x19323L                      15.20            45.j

-786    0122L                              -21.9            9.322e-36j

080      0xDEFABCECBDAECBFBAEl   32.3e+18      .876j

-0490   535633629843L                   -90.              -.6545+0J

-0x260  -052318172735L                  -32.54e100    3e+26J

0x69    -4721885298529L                 70.2E-12      4.53e-7j

 

 

Python 保留字符

下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数，或任何其他标识符名称。

 

所有 Python 的关键字只包含小写字母。

and       exec        not

assert      finally            or

break      for           pass

class        from        print

continue  global        raise

def       if             return

del        import       try

elif        in            while

else       is            with

except     lambda       yield

 

基础语法

转义序列：

\\ \t \r \n \’ \”

 

model:

print(“I\’m OK.”)

I’m OK.

 

print(“I\’m \\OK.”)

I’m \OK.

 

print(“I\’m \tOK.”)

I’m     OK.制表

 

print(“I\’m \nOK.”)

I’m 换行

OK.

 

print(r”I\’m OK.”)

I\’m OK. r”:”内的字符串默认不转义

 

print(‘\\\t\\’)

\       \

 

print(‘\\\n\\’)

\

\

缩进：

1、未使用C等语言的花括号，而是采用缩进的方式表示层次关系

2、约定使用4个空格缩进

 

续行：

1、在行尾使用\

2、如果使用各种括号，认为括号内是一个整体，内部跨行不用\

 

变量赋值：

counter = 100 # 赋值整型变量

miles = 1000.0 # 浮点型

name = “John” # 字符串

 

print counter

print miles

print name

 

标准数据类型

Numbers（数字）

String（字符串）

List（列表）

Tuple（元组）

Dicionary（字典）

 

标识符：

1、一个名字，用来指代一个值

2、只能字母、下划线和数字

3、只能以字母或下划线开头

4、不能是python的关键字，例如def、class不能作为标识符

5、python是大小写敏感的

约定：

不允许使用中文

不允许使用歧义单词，例如class_

在python中不要随便使用下划线开头的表示符

 

常量：

一旦赋值就不能改变值的标识符

python中无法定义常量

 

字面常量：

一个单独的量，例如12、“ABC”、‘2341.09e-9’

 

变量：

赋值后，可以改变值的标识符

# python语言类型

1、python是动态语言、强类型语言

动态编译语言：

不用事先声明类型，随时可以赋值为其他类型

编程时不知道是什么类型，很难推断

强类型语言

不同类型之间操作，必须先强制类型转换为同一类型

 

运算符：

+：加，两个对象相加

-：得到负数或是一个数减去另一个数

*：两个数相乘或是返回一个被重复若干次的字符串

/：x除以y

%：取模，返回除法的余数

**：幂，返回x的y次幂

//：取整除，返回商的整数部分

备注：开篇就说过2.x和3.x区别

自然除／结果是浮点数，整除//

 

位运算符：

&：按位与运算符：参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0

例如：a = 20 b =10

a&b即为：

20用二进制表示：0001 0100

10用二进制表示：0000 1010

这样得出a&b的值就为0

In [11]: a = 20

 

In [12]: b = 10

 

In [13]: print(a&b)

0

|：按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1

a|b二进制结果为：0001 1110即为30

In [14]: print(a|b)

30

^：按位异或运算符：当两个对应的二进位相异时，结果为1

In [15]: print(a^b)

30

这个刚好和a|b结果一样

假如：a = 5 b = 3

0000 0101

0000 0011

0000 0110 结果为6，而a|b为7

～：按位取反运算符：对数据的每个二进制位取反，即把1变为0，把0变为1

例如：～8

即：     0000 1000

按位取反：1111 0111

补位取反：0000 1001 得出值为-9

 

例如：60

0011 1100

1100 0011

0011 1101 得值-61

<<：左移动运算符：运算数的各二进位全部左移若干位，由”<<“右边的数指定移动的位数，高位丢弃，低位补0

In [24]: 2<<3

Out[24]: 16

值的由来：0000 0010 向左移动两位：0001 0000得值16

 

In [25]: 100<<2

Out[25]: 400

 

0110 0100

移动： 1 1001 0000 即2*8 + 2*7 + 2*4 = 400

>>：右移动运算符：把”>>”左边的运算数的各二进位全部右移若干位，”>>”右边的数指定移动的位数

In [29]: 2 >> 2

Out[29]: 0

0000 0010 移动：0000 0000

 

In [30]: 200 >> 3

Out[30]: 25

1100 1000 移动 0001 1001 = 25

 

10^9=3 10^-9=-3

比较运算符：

== != > < >= <=

返回一个bool值

1 < ‘1’ 1 == ‘1’

 

==如果两个操作数的值相等，则条件为真。

!= 如果两个操作数的值不相等，则条件为真。

>如果左操作数的值大于右操作数的值，则条件成真

<如果左操作数的值小于右操作数，则条件为真

>=如果左操作数的值大于或等于右操作数的值，则成为真

<=如果左操作数的值小于或等于右操作数的值，则条件为真

逻辑运算符：

与或非 and or not

and：如果两个操作数都为真，则条件成立

or：如果两个操作数中的任何一个非零，则条件成为真

not：用于反转操作数的逻辑状态

 

短路运算符

and 如果第一个表达式为False，后面就没用必要计算了，这个逻辑表达式一定是False

or 如果第一个表达式True，后面没有必要计算了，这个逻辑表达式一定是True

 

赋值运算符：

a = min(3,5)

+= -= *= /= %=

=：将右侧操作数的值分配给左侧操作数

+=：将右侧操作数相加到左操作数，并将结果分配给左操作数

-=：从左操作数中减去右操作数，并将结果分配给左操作数

*=：将右侧操作数与左侧操作数相乘，并将结果分配给左操作数

／=：将左侧的操作数除以右操作数，并将结果分配给左操作数

%=：将左操作数除以右操作数的模数，并将结果分配给左操作数

**=：执行指数（幂）计算，并将值分配给左操作数

//=：取整除 – 返回商的整数部分

 

成员运算符：

in、not in

身份运算符：

is、is not

 

运算符优先级：

运算符                                   描述

**                                     指数(最高优先级)

~ + –                                   按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)

* / % //                                乘，除，取模和取整除

+ –                                  加法减法

>> <<                                右移，左移运算符

&                                     位 ‘AND’

^ |                                   位运算符

<= < > >=                         比较运算符

<> == !=                                   等于运算符

= %= /= //= -= += *= **=      赋值运算符

is is not                        身份运算符

in not in                      成员运算符

not or and                          逻辑运算符

 

表达数：

由数字、符号、括号、变量等的组合

1、算数表达式

2、逻辑表达式

3、赋值表达式

python中，赋值即定义，如果一个变量已经定义，赋值相当于重新定义

 

内存管理

变量无须事先声明，也不需要指定类型

动态语言的特性

编程中一般无须关心变量的存亡，也不用关心内存的管理

python使用引用计数记录所有变量的引用数

当变量引用数变为0时，它可以被垃圾回收gc

计数增加：赋值给其它变量就增加引用计数，例如x=3;y=x

计数减少：

函数运行结束时，局部变量会自动销毁，对象引用计数减少

变量被赋值给其它对象。例如x=3;y=x;x=4

有关性能的时候，就需要考虑变量的引用问题，但是该释放内存，还是尽量不释放内存，看需求

 

程序控制

顺序：

按照先后循序一条条执行

分支：

根据不同的情况判断，条件满足执行某条件下的语句

循环：

条件满足就反复执行，不满足就不执行或不再执行

 

单分支结构：

if语句

if condition:

代码块

condition必须是一个bool类型，这个地方有一个隐式转换

if 1<2:

print(‘1 less than 2’)

代码块：

类似于if语句的冒号后面的就是一个语句块

在if、for、def、class等

 

多分支结构：

if…elif…else语句

if condition1:

代码块1

elif condition2:

代码块2

elif condition3:

代码块3

…

else：

代码块

分支嵌套：

score = 80

if score<0:

print(‘wrong’)

else:

if score == 0:

print(‘egg’)

elif score <= 100:

print(‘right’)

else:

print(‘too big’)

 

分支嵌套：

嵌套结构，可以是分支、循环的嵌套

可以互相嵌套多层

model：

score = 80

if score < 0:

print(‘wrong’)

else:

if score == 0:

print(‘egg’)

else score <= 100:

print(‘right’)

else:

print(‘too big’)

循环–while语句：

语法：

while condition:

block

当条件满足即condition为True，进入循环体，执行block

model：

flag = 10

while flag:

print(flag)

flag -= -1

 

循环continue语句：

中断当前循环的当次执行，继续下一次循环

model：计算10以内的偶数（for循环）

for i in range(10):

if not i%2:

print(i)

 

循环break语句

终止当前循环

model：

计算1000以内的被7整除的前20个数（for循环）

count = 0

for i in range(0,1000,7):

print(i)

count += 1

if count >= 20:

break

 

循环else子句：

语句：

while condition:

block

else:

block

for elemen in iteratable:

block

else:

block

如果循环正常的执行结束，就执行else子句；如果使用break终止，else子句不会执行

 

几个语句的详细解析如下：

 

程序控制：

if语句：

if condition   condition：[kənˈdɪʃn]

代码块

condition必须是一个bool类型，这个地方有一个隐式转换bool(condition)

 

bool：是Boolean缩写，只有真（True）和假（False）两种取值。

bool函数只有一个参数，并根据这个参数的值返回真或者假

 

“”,0,(),[],{},None：值都为假

空集合：

空字符串

空字典

空列表

空元组

 

model：

In [21]: bool(1)

Out[21]: True

 

In [22]: bool(0)

Out[22]: False

 

In [23]: if 1<2:

…:     print(‘1 less than 2’)

…:

1 less than 2

 

代码块：

类似于if语句的冒号后面就是一个语句块

在if、for、def、class等。

 

 

Python 编程中 if 语句用于控制程序的执行，基本形式为：

 

if 判断条件：

执行语句……

else：

执行语句……

 

 

model：

num = 3

name = ‘Eric’

if name == ‘Eric’:

print(‘Welcome Eric’)

else:

print(num)

结果是：Welcome Eric

 

if 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。

当判断条件为多个值时，可以使用以下形式：

if 判断条件1:

执行语句1……

elif 判断条件2:

执行语句2……

elif 判断条件3:

执行语句3……

else:

执行语句4……

 

model：

name = input(“Please enter a name: “)
if name == ‘Eric’:
print(‘Welcome 魏都酒狂泰谷子‘)
elif name == ‘zhangsan’:
print(‘old man’)
elif name == ‘lisi’:
print(‘young’)
else:
print(‘child’)

 

分支嵌套：

由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现，如果判断需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。

 

num = 9
if num >= 0 and num <= 10:  # 判断值是否在0~10之间
print(‘hello’)
# 输出结果: hello

num = 10
if num < 0 or num > 10:  # 判断值是否在小于0或大于10
print(‘hello’)
else:
print(‘undefine’)
# 输出结果: undefine
num = 8
# 判断值是否在0~5或者10~15之间
if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):
print(‘hello’)
else:
print(‘undefine’)
# 输出结果: undefine

 

练习：给定一个不超过5位的正整数，判断其有几位。

num = 13468
if num >= 1000:
if num >= 10000:
print(“5”)
else:
print(‘4’)
else:
if num >= 1000:
print(‘3’)
elif num >= 100:
print(‘2’)
else:
print(‘1’)

方法较多，不一一列举，发散思维。例如，可以使用if…elif…elif…

 

 

 

 

 

循环：

 

上面的打印出来是偶数，下面为奇数

 

多种实现：

那么上面的相反，把==0换成==1，打印出来的就是偶数了。

 

while语句：

while condition：

block #：当条件满足即condition为True，进入循环体，执行block。

num = 1
while num <9:
print(num)
num += 1 #不限定此条件的话，num从1开始，小于9，会一直循环下去，进入死循环。

 

while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于退出循环，此外”判断条件”还可以是个常值，表示循环必定成立，具体用法如下：

model：

num = int(input(‘>>>’))
while num < 100:
num += 1
if num > 50:
continue
print(‘ok’)

 

model1:

# continue 和 break 用法
i = 1
while i < 10:
i += 1
if i % 2 > 0:  # 非双数时跳过输出
continue
print(i)  # 输出双数2、4、6、8、10

i = 1
while 1:  # 循环条件为1必定成立
print(i)  # 输出1~10
i += 1
if i > 10:  # 当i大于10时跳出循环
break

从上面就可看出continue和break的区别，一个是跳出该次循环，一个是退出循环。

 

逆序排列：

flag=10
while flag:
print(flag)
flag -= 1

 

正序排列：

for i in range(10):
print(i)

 

加：

for i in range(10):
i+=1
print(i)

或者：

for i in range(10):
print(i+1)

 

count = 0
for i in range(0,10000,7):
print(i)
count += 1
if count < 4:
print(‘ok’)
else:
break

 

给定一个5位的正整数，判断其有几位，依次打印出个位，十位，百位，千位，万位的数字。

val = input(‘>>>’)
val = int(val)
if val >= 1000: #
if val>=10000: num = 5
else:
num = 4
else:
if val>=100:
num = 3
elif val >= 10:
num = 2
else:
num = 1
print(num)
pre = 0
for i in range(num,0,-1): #从上面的出的num值进行循环，步长-1
cur = val//(10**(i-1)) #cur的值为：输入的5位数整除10**（5-1），第一次循环得出万位数，依次类推
print(cur – pre*10) #如当num为4时，pre为1

 

循环else子句：

while condition:
block
else:
block
for element in iteratable:
block
else: block

 

练习，打印一个边长为n的正方形：

实心：

for i in range(4):
for i in range(4):
print(‘*’,end=‘  ‘)
print(‘\t‘)

 

空心的属于网络摘抄：

rows = int(input(‘输入列数： ‘))
for i in range(0, rows):
for k in range(0, rows):
if i != 0 and i != rows – 1:
if k == 0 or k == rows – 1:
print(” * ” ,end=“”)#由于视觉效果看起来更像正方形，所以这里*两侧加了空格，增大距离
else:
print(”   “,end=“”) #该处有三个空格

else:
print(” * “,end=“”) #这里*两侧加了空格
k += 1
i += 1
print(“\t“)

 

2、求100以内所有奇数的和。

sum = 0
for i in range(1,100,2):
sum += i
print(sum)