phthon基本语法——温习

phthon基本语法——温习

1 注释

单行注释：#
多行注释：

””” 多行注释 “”” 

’’’ 多行注释 ‘’’

2 算数运算

+加
-减
*乘
/除
//整除： 9//2=4
% 余数： 3%2=1
** 幂： 2**3=8

”hello”*3  >>>>hello hello hello

注意：

• 变量名在第一次出现时才是定义变量
• 变量名=值

3 数据类型

（1）数字型
bool: 布尔： 非零即真（True），数字0（False ）
int: 整数 （不需要划分数据长度long等，整数只有一个int型）
float: 浮点数
complex 复数: a=complex(real,imag)

注意：
数字型变量之间可以直接计算
（2）非数字型

• 字符串
• 列表
• 元组
• 字典

注意：
type（变量名）函数可以查看变量的具体类型

字符串变量之间使用+拼接字符串

a=”k”  
b=”r”  
c=a+b >>>c=kr

使用*重复拼接字符串：”hello”*3

a=input(“请输入”)  #返回字符串类型

4 类型转换函数

int(x)  #将x转换为整数
 int(“123”)  >>> 123
 
float(x)  #将x转换为浮点数  
float(“12.3”)  >>>12.3
a=float(input(“单价”))

5 变量的格式化输出：

格式化字符：
%s 字符串
%d 有符号十进制整数： %06d：输出的整数位数
%f 浮点数 ： %.02f:小数点后只显示两位小数
%% 输出%

a=”小明”
print(“%s” % a)  >>>小明

scale = 0.57
print(“数据比例是 %f%%” % (scale*100))  >>>>数据比例是 57%

name1=”小明”
name2=”小红”
print(“玩家1 %s  玩家2 %s ” % (name1,name2))  >>>>玩家1 小明  玩家2小红

6 变量的命名

标识符即变量名、函数名
标识符：字母、数字、下划线, 不能以数字开头、不能为关键字.

命名规则：标识符区分大小写
= 左右保留空格
1）所有字母小写,中间用_分割。 hello_world
2）小驼峰命名：helloWorld 首字母小写，后续首字母大写
3）大驼峰命名：HelloWorld 每个单词首字母都采用大写

import keyword
print(keyword.kwlist)  
>>>关键字列表输出:
'False',  'None',  'True',  'and',  'as',  'assert', 
'break',  'class',  'continue',  'def',  'del', 
'elif',  'else', 'except',  'finally', 'for',  'from', 
'global',  'if',  'import', 'in',  'is',  'lambda', 
'nonlocal',  'not',  'or',  'pass',  'raise',  'return', 
'try', 'while',  'with',  'yield'

注意：
使用关键字不需要()

7 if 判断语句

if 要判断的条件:   
	if 要判断的条件:  #代码缩进一个Tab键或空格不能混用
   
	else:
else:

（1）比较运算符

==
!=
>
<
>=  #之间不能有空格
<=

age=int(input(“年龄:”))
if age >= 18:
	print(“满足年龄要求”)
else:
	print(“禁止入内”)

(2) 逻辑运算符

and 与
or 	或
not	非

is_employee = True
if not is_employee:
	print(“非本公司人员，请勿入内”)

if语句进阶

if 条件1：
	pass
elif 条件2：
	pass
else:
	pass

if嵌套

if  条件:   
	if 条件: 
		pass                
	else:
		pass
else:
	pass

过长表达式换行：

if ((paly1 == 1 and paly2 == 1) 		#切换过长表达式
		or (play1 ==2 and play2 ==1 )    #空两个Tab
		or (play1 ==1 and play2 == 2))
	print(“done”)

随机整数：

import random
random.randint(a,b)  #返回a,b之间的一个整数

8 循环

• 顺序
• 分支
• 循环

while语句基本用法

初始条件设置

while 条件：
	pass

i=1
while i<=5:
	print(“helloworld”)
	i=i+1

死循环：（循环内没有加判断条件处理）

i=1
while i<=5:
	print(“helloworld”)

（1）赋值运算符

=
+=
-=
*=      c=c*b等效于c*=b 
/=
//=
%=
**=

（2）break和continue

（只针对当前所在循环，即一层循环有效）
break:条件不满足时退出整个循环，不再执行后续循环
continue:条件不满足时，退出当次循环，继续后续循环

循环嵌套
print 默认会换行，end=””用空格代替换行

print(“8”)
print(“8”)   #print 默认会换行
print(“*”,end=””)  #end=””用空格代替换行

print(“*”,end=”+++”) 
print(“*”)   >>>> *+++*

打印小矩形：

row=1
while row<=10
	col=1
	while col <=row
		print(“*”,end=””)
		col += 1
	print(“”)       #执行完一行后，手动换行
	row +=1

九九乘法表：

row=1
while row<=9
	col=1
	while col <=row
		print(“%d*%d=%d”, % (col,row,(row*col)),end=”\t”)
		col += 1
	print(“”)       #执行完一行后，手动换行
	row +=1

（3）字符串中的转义字符

\\  反斜杠符号
\’	单引号
\”	双引号
\n	换行
\t	横向制表符
\r	回车

print(“a\tb\tc\t”)  >>> a	b	c

9 函数基础

def 函数名():
	“”” 函数文档注释 “””
	pass    #函数内部只有调用时才会执行，定义函数时不执行。

函数名()  #函数调用

def sum(a,b):  #形参
	result = a + b
	#print(“%d + %d = %d ” % (a,b,result))
	return result
	
a=sum(50,20)   #实参
print(a)  >>>70

（1）函数的嵌套调用

def test1():
	print(“*”*20)

def test2():
	test1()
	print(“**”*50)

test2()

（2）模块

import 模块名
import 模块名 as 别名
from 模块名 import *
from 模块名 import 函数名 as 别名

注意：
pyc文件：编译（compile）过的文件，即将模块的源码转换为字节码，增加运行效率。

10 列表

(使用最频繁)—对应于其它语言的数组，可以存储不同类型的数据。
list

name = [“小明”,”Rock”]  #计数从0开始

创建列表：

name = []

列表函数：
（1）增加
[].insert(索引,数据) #在指定位置插入数据
[].append(数据) #在末尾添加数据
[].extend(列表2) #将列表2中的数据添加到列表中

（2）修改

列表[索引] = 数据  
#name[0] = “cbj”

（3）删除
列表.remove[数据] #删除第一个出现的指定数据
列表.pop() #删除末尾数据
del 列表[索引] #删除指定索引的数据
列表.pop(索引) #删除指定索引数据 （用这个）
列表.clear() #清空列表

（4）统计
len(列表) #列表长度
列表.count(数据) #数据在列表中出现的次数

（5）排序
列表.sort() #升序排序
列表.sort(reverse=True) #降序排序
列表.reverse() #逆序，反转

name = [“小明”,”Rock”] 
name.index(“小明”)  #返回数据对应的索引位置  >>>  0

del name  #在内存中删除变量

注意：
方法：封装了独立功能，通过对象调用， 对象.方法名(参数)

循环遍历：

name = [“小明”,”Rock”] 
for my_name in name:
	print(“我的名字：%s” % my_name)

11 元组

• Tuple 元组中保存的数据类型往往是不一样的
• 元素不能修改

创建空元组： tuple = () #使用很少

into_tuple = (“zhang”,18)

元组只有一个元素时，需要在元素后面添加逗号,

into_tuple = (5)  
>>> type(into_tuple)  >>> int 整数类型
 
into_tuple = (“zhang”, )  
>>> type(into_tuple)  >>> tuple 元组类型

方法

into_tuple = (“zhang”,18)
into_tuple.index(18)  >>>  1

into_tuple.count(“zhang”)   >>>1
into_tuple.len() 

into_tuple = (“zhang”,18)
print(“%s 年龄是 %d” % into_tuple)

拼接新的字符串（元组拆解）：

info = “%s 年龄是 %d” % into_tuple   #拼接新的字符串
print(info)

元组和列表之间的转换：

num_list = [1,2,3,4]			>>>list
num_tuple = tuple(num_list)   >>> tuple

num_list1 = list(num_tuple)    >>>list

12 字典

• 键值对
• 字典是无序的对象集合
• 值可以是任何数据类型，键只能是字符串、数字或元组

xiaoming = { “name”:”小明”，”age”:18}

取值：

print( xiaoming[“name”] ) >>>小明

增加/修改：

xiaoming[“gender”] = True

删除：

xiaoming.pop(“name”)  #删除指定Key

键值对数量：

len(xiaoming) 

字典合并

#合并时，此处age会覆盖原有的键值对
temp_dict = {“height”:1.75,”age”:25}   
xiaoming.update(temp_dict)  
>>>{“name”:”小明”,“height”:1.75,”age”:25}

xiaoming.clear()  #清空字典

for遍历
for循环遍历所有非数字型的数据类型：列表、元组、字典、字符串

xiaoming = { “name”:”小明”，”age”:18}
for k in xiaoming:  # k每次循环获取到键值对的key
	print(“%s----%s” %(k,xiaoming[k]))

card_list = [ { “name”:”小明”，”age”:18},
 { “name”:”Rock”，”age”:28}
]
for card_info in card_list:
	print(card_info)

13 字符串

一对单引号或双引号定义字符串

（1）去掉空格和特殊符号

name.strip('xx') #去掉某个字符串
name.strip() #去掉空格和换行符
name.lstrip() #去掉左边的空格和换行符
name.rstrip() #去掉右边的空格和换行符

（2）字符串的查找和替换

name.count('x') #查找某个字符在字符串里面出现的次数
name.capitalize() #首字母大写
name.center(n,'-') #把字符串放中间，两边用- 补齐
me.find('x') #找到这个字符返回下标，多个时返回第一个；不存在的字符返回-1
name.index('x') #找到这个字符返回下标，多个时返回第一个；不存在的字符报错
name.replace(oldstr, newstr) #字符串替换,返回一个新的字符串
name.format（） #字符串格式化
name.format_map(d) #字符串格式化，传进去的是一个字典

（3）字符串的测试和替换函数

S.startswith(str) #是否以str开头
S.endswith(str) #以str结尾

S.isdecimal() #判断数字，整数
S.isdigit() #是否全是数字，并至少有一个字符 整数
S.isnumeric() #是否全是字母和数字，并至少有一个字符 整数

S.isalpha() #是否全是字母，并至少有一个字符
S.isspace() #是否全是空白字符，并至少有一个字符 ，\t \n \r 都是空白
S.islower() #S中的字母是否全是小写
S.isupper() #S中的字母是否便是大写
S.istitle() #S是否是首字母大写的

（4）字符串的分割

name.split() #默认是按照空格分割

name.split(',') #按照逗号分割

（5）连接字符串

‘ , ’.join(slit) 用逗号连接slit 变成一个字符串

注意：
slit可以是字符，列表，字典（可迭代的对象） ，int 类型不能被连接

（6）截取字符串（切片）

字符串(开始索引：结束索引：步长)

str = '0123456789′
str[0:3] #截取第一位到第三位的字符
str[:] #截取字符串的全部字符
str[6:] #截取第七个字符到结尾
str[:-3] #截取从头开始到倒数第三个字符之前
str[2] #截取第三个字符
str[-1] #截取倒数第一个字符
str[::-1] #创造一个与原字符串顺序相反的字符串 同 str[-1::-1]
str[-3:-1] #截取倒数第三位与倒数第一位之前的字符
str[-3:] #截取倒数第三位到结尾
str[:-5:-3] #逆序截取，步长为-3，所以为逆序

（7）大小写转换
S.capitalize() #第一个字符大写
S.title() #每个单词首字母大写
S.lower() #所有大写字符为小写
S.upper() #所有小写字符为大写
S.swapcase() #翻转大小写

（8）文本对齐
S.ljust(width) #左对齐
S.rjust(width) #右对齐
S.center(width,” ”) #居中

14 公共方法

——（字典、元组、列表共用的）

len()
del()
max()  #字典只针对key比较
min()	#字典只针对key比较

切片：列表、字符串、元组
* + 拼接可以应用于：列表、元组、字符串 产生新的列表、元组、字符串

(1,2)*2  >>> (1,2,1,2)
(1,2)+(1,2) >>>(1,2,1,2)

str = [1,2]
str.append([3,4])  >>>[1,2,[3,4]]
str.extend([3,4])   >>> [1,2,3,4]

in，not in 元素是否存在，字典只针对键key

完整的for循环

for 变量 in 集合：
	pass  #有break时else不会执行
else: 	#集合元素遍历结束会执行
	pass

15 变量进阶

变量和数据是分开保存的；
数据保存在内存中的一个位置；
变量保存数据在内存中的地址，记录数据的地址，就叫引用；

id(变量名)  >>>变量引用的地址

可变和不可变类型

不可变类型：（内存中的数据不可被修改）

数字类型：int  bool  float  complex 
字符串	str
元组	tuple

可变类型：（内存中的数据可以被修改）

列表	list
字典	dict

a=[1,2,3]
a=[2,3,4]  #赋值时是在改变变量的引用地址，而不是在修改内存中的内容

16 哈希（hash）

hash(o) #接收一个不可变类型的数据作为参数，返回结果是一个整数（特征码）

17 局部变量和全局变量

• 局部变量在函数执行时创建，在执行结束后被系统回收；
• 不同函数中的同名局部变量没有影响；

不能在函数内部修改全局变量

num=10
def demo():
	num=99   #此处是定义了一个局部变量
	print(num)

要在函数内部修改全局变量需要在函数内部声明全局变量global

num=10
def demo():
	global num  #声明全局变量
	num=99   #此处是定义了一个局部变量
	print(num)

注意：
全局变量前缀加g_ 或 gl_

18 函数

def demo():
num=99   #此处是定义了一个局部变量
num01=999
#return (num,num01)
return  num,num01    #同样返回元组
#变量个数和元组个数应该相同
num , num1 = demo()      #接收返回值

交换两个数字的值：

a=2  
b=3
a , b = b, a   #python专有   同a,b = (b,a)  等号右边是一个元组

如果传递的参数为可变类型：列表、字典，在函数内部使用方法修改了数据的内容，同样会影响到外部的数据

def demo(num_list):
	num_list.append(88)

gl_list = [1,3,4]
demo(gl_list)
print(gl_list)  >>>   [1,3,4,88]

使用方法，并不会改变变量的指向，使用赋值语句，会改变变量的指向。
注意列表变量调用+=实质上是列表变量执行extend方法，并不会修改变量的引用。

使用+=

def demo(num_list):
	num_list += num_list

gl_list = [1,3]
demo(gl_list)
print(gl_list)  >>>   [1,3,1,3]

使用赋值语句=

def demo(num_list):
	num_list = num_list + num_list   #使用赋值语句

gl_list = [1,3]
demo(gl_list)
print(gl_list)  >>>   [1,3]

(1) 缺省参数：函数的设置默认值的参数

def demo(name,gender=True):  #缺省参数需要排在参数列表的末尾
	pass

(2) 多值参数：一个函数能够处理参数的个数是不确定的

*args  可以接收元组
**kwargs 可以接收字典

def demo(num,*args,**kwargs):
	print(num)
	pirnt(args)
	print(kwargs)
demo(1,2,3,4,name=”rock”,age=18)  
>>>1 
>>>(2,3,4) 
>>>{‘name’:’rock’,’age’:18}

(3) 函数递归：调用函数自身
针对参数的不同，处理的结果不同，当参数满足一个条件时，函数不再执行。

def sum_number(num):
	print(num)
	if num == 1:   #递归的出口
		return 1
	temp = sum_number(num-1)
	return  num+temp
sum_number(3)    >>>6

19 元组和字典的拆包

• 在元组变量前，增加一个*
• 在字典变量前，增加两个**

def demo(*args,**kwargs):
	pirnt(args)
	print(kwargs)

gl_nums = (1,2,3)
gl_dict = {name=”rock”,age=18}

demo(gl_nums ,gl_dict) 
>>>((1,2,3), {name=”rock”,age=18})   #gl_nums、gl_dict都传递到一个元组中
>>>{} 

demo(*gl_nums ,**gl_dict)  #简化元组变量和字典变量的传递
>>>(2,3,4) 
>>>{‘name’:’rock’,’age’:18}