Python基础

Python基础

变量定义

变量的概念基本上和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。
变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，且不能用数字开头，比如：

a = 1

字符串的格式化

格式化有两种方法：
利用百分号（%）
利用format函数

利用百分号格式化

在字符串中，利用%表示一个特殊的含义，表示对字符进行格式化%d: 此处应该放入一个整数%s: 表示此处应该放入一个字符串:

print("I love %s"%"C++")

输出结果为：I love C++

format函数格式化字符串

直接用format函数进行格式化- 推荐使用这种方法。
在使用上，以{}和.代替%号，后面用format带参数完成format函数格式化字符串。

s = "I love {}".format("Python")
print(s)
s = "Yes, i am {1} years old, I love {0} and i am {1} years old".format("Python", 18)
print(s)

运算符

算数运算符

# +,-跟正常算术运算符一模一样
a = 9+3-2
print(a)
# 乘号用星号(*)代替
a = 9 * 4
print(a)
# 除号用斜杠(/)代替
# 在Python2.x 和python3.x 中，除号(/)结果可能不一致，此处以3系列为准
a = 9/4
print(a)
# % 取余运算
# 两个数字相除应该有商数有余数
# % 只会得到余数
a = 9 % 4
print(a)
# // 表示取商运算，也叫地板除
a = 9 // 4
print(a)
# ** 表示幂运算
a = 9 ** 4
print(a)

赋值运算符

# = , 赋值
a = 0
c = a = 4
# +=, 是缩写，
a = 0
a += 7 # a = a+ 7 的缩写
print(a)

逻辑运算符

and 逻辑与
or 逻辑或
not 逻辑非

a = True
b = False
c = True
# 以下式子等价于 d = 1 * 0 + 1
d = a and b or c
print(d)
d = a or b and a
print(d)

成员运算符号-用来检测某一个变量是否是另一个变量的成员

in
not in

l = [1,2,3,4,5]
a = 7
b = a in l
print(b)
a = 4
print(a in l)
print(a not in l)

输出结果为：
False
True
False

身份运算

is: 用来检测两个变量是否是同一个变量
语法就是 var1 is var2
is not: 两个变量不是同一个变量

a = 9
b = 9
print( a is b)

a = "I love Python"
b = "I love Python"
print( a is b)

输出结果为：
True
False

三大结构

顺序
分支
循环

分支

分支的基本语法

 if 条件表达式：
    语句1
    语句2
    语句3

#案例
score = 59
if  score < 60:
    print("恭喜你")
    print("高数不及格")
print("finished")

输出结果为：
恭喜你
高数不及格
finished

双向分支

if…else…语句 `

if 条件表达式:
      语句1
      语句2
      ...
else:
      语句1
      语句2
      .....

多路分支

if  条件表达式：
      语句1
      ....
  elif 条件表达式：
      语句1
      ...
  elif 条件表达式：
      语句1
      ...

  .....
  else:
      语句1
      ....

循环语句

分类：
for循环
while循环

for循环

for 变量 in 序列：
      语句1
      语句2
      ...

# 打印学生列表姓名
for name in  ['zhangsan', 'lisi', 'wangwu','jingjing']:
    print(name)

输出结果为：
zhangsan
lisi
wangwu
jingjing

range函数

# range练习
# 打印从1-10的数字
# 注意，一般在python中，如果由表示数字范围的两个数，一般是包含左边数字不包含右边数字
# range函数在python2 和 python3中有严重区别(2生成列表，3生成迭代器)
for i in range(1,11):
    print(i) 

输出结果：
1
2
3
4
5
6
7
8
9
10

for-else语句

当for循环结束的时候，会执行else语句
else语句是可选语句

for name in  ['zhangsan', 'lisi', 'wangwu','jingjing']:
    print(name)
    if name == "jingjing":
        print("{0}同学高数不及格".format(name))
    else:
        print("{0}同学高数ok".format(name))
else:
    print("没有其他同学的高数成绩了")

输出结果为：
zhangsan
zhangsan同学高数ok
lisi
lisi同学高数ok
wangwu
wangwu同学高数ok
jingjing
jingjing同学高数不及格
没有其他同学的高数成绩了

函数

定义

# 定义一个函数
# 只是定义的话不会执行
# 1. def关键字，后跟一个空格
# 2. 函数名，自己定义，起名需要遵循便令命名规则，约定俗成，大驼峰命名只给类用
# 3. 后面括号和冒号不能省，括号内可以由参数
# 4. 函数内所有代码缩进
def func():
    print("我是一个无情的函数")
print("我结束了")

输出结果为：
我结束了

# 函数的调用
# 直接函数名后面跟括号
func()

输出结果为：
我是一个无情的函数

函数的参数与返回值

参数： 负责给函数传递一些必要的数据或者信息
形参（形式参数）： 在函数定义的时候用到的参数没有具体值，只是一个占位的符号，成为形参
实参（实际参数）： 在调用函数的时候输入的值
返回值： 函数的执行结果使用return关键字
如果没有return，默认返回一个None函数
一旦执行return语句，则无条件返回，即结束函数的执行

def hello(person):
    print("{0},你好".format(person))
    print("{0},再见".format(person))
  
p = 1
hello(p)

1,你好
1,再见

# return语句的基本使用
# 函数打完招呼后返回一句话
def hello(person):
    print("{0},你好".format(person))
    print("{0},再见".format(person))
    return "我已经跟{0}打过招呼了".format(person)
  
p = "小明"
rst = hello(p)
print(rst)

小明,你好
小明,再见
我已经跟小明打过招呼了

参数详解

参数分类
普通参数
默认参数
关键字参数
收集参数

def stu(name, age, addr):
    print("I am a student")
    print("我叫 {0}， 我今年 {1}岁了， 我住{2}".format(name, age, addr))
    
    
n = "jingjing"
a = 18
addr = "我家"

# 普通参数，只按照位置传递，容易出错
stu(a, n, addr)

def stu_key(name="No name", age=0, addr="No addr"):
    print("I am a student")
    print("我叫 {0}， 我今年 {1}岁了， 我住{2}".format(name, age, addr))
    
    
n = "jingjing"
a = 18
addr = "我家"

# 关键字参数，不容易出错
stu_key(age=a, name=n, addr=addr)

输出结果为：
I am a student
我叫 18， 我今年 jingjing岁了， 我住我家
I am a student
我叫 jingjing， 我今年 18岁了， 我住我家

收集参数

把没有位置，不能和定义时的参数位置相对应的参数，放入一个特定的数据结构中

def func(*args):
      func_body
      按照list使用方式访问args得到传入的参数

  调用：
  func(p1, p2, p3, .....)

参数名args前需要由星号收集
参数可以和其他参数共存

# 收集参数代码
# 函数模拟一个学生进行自我介绍，但具体内容不清楚
# args把他看做一个list
def stu( *args):
    print("Hello 大家好，我自我介绍以下，简答说两句：")
    # type函数作用是检测变量的类型
    print(type(args))
    for item in args:
        print(item)

stu("小明", 18, "北京", "小芳", "单身")
stu("小明")

输出结果为：
Hello 大家好，我自我介绍以下，简答说两句：
<class ‘tuple’>
小明
18
北京
小芳
单身
Hello 大家好，我自我介绍以下，简答说两句：
<class ‘tuple’>
小明

收集参数之关键字收集参数

把关键字参数按字典格式存入收集参数

 def func( **kwargs):
      func_body

  # 调用：
  func(p1=v1, p2=v2, p3=v3........)

# 收集参数案例
# 自我介绍
# 调用的时候需要使用关键字参数调用
def stu( **kwargs):
    # 在函数体内对于kwargs的使用不用带星号
    print("Hello 大家好，我先自我介绍一下：")
    print(type(kwargs))
    # 对于字典的访问，python2 和python3有区别
    for k,v in kwargs.items():
        print(k, "---", v)
stu(name="小明",  age=19, addr="北京", lover="小芳", work="程序员")
print("@" * 50)
stu(name="小明")

Hello 大家好，我先自我介绍一下：
<class ‘dict’>
name — 小明
age — 19
addr — 北京
lover — 小芳
work — 程序员
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Hello 大家好，我先自我介绍一下：
<class ‘dict’>
name — 小明

收集参数的解包问题

把参数放入list或者字典中，直接把list/dict中的值放入收集参数中

# 收集参数的解包问题
def stu(*args):
    print("哈哈哈哈哈")
    # n 用来表示循环次数
    # 主要用来调试
     n = 0
    for i in args:
        print(type(i))
        print(n)
        n += 1
        print(i)
li = ["小明","小芳"]
stu(*li)

输出结果为：
哈哈哈哈哈
<class ‘str’>
0
小明
<class ‘str’>
1
小芳

同理，dict类型收集参数一样可以解包，但是¶对dict类型进行解包需要用两个星号进行解包

局部变量为全局变量

使用global

def fun():
    global b1
    b1 = 100
    print(b1)
    print("I am in fun")
    # a2的作用范围是fun
    b2 = 99
    print(b2)

#print(b2)
fun()
# print(b1)如果在函数调用上面，则不好使，报错，为什么？？？
print(b1)

输出结果为：
100
I am in fun
99
100

Python内置数据结构

列表

# 1, 创建空列表
l1 = []
print(l1)
# 2. 创建带值的列表
l2 = [100]
print(l2)
# 3. 使用list()
l3 = list()
print(type(l3))
print(l3)

列表常用操作

访问

# 下标访问列表
l = [3,2,1,4,6,3,2]
print(l[3])

输出结果为：
4

切片

# 切片操作
# 注意截取的范围，包含左边的下标值，不包含右边的下标值
print(l[1:4])
# 下标值可以为空，如果不写，左边下标值默认为0， 右边下标值为最大数加一，即表示截取到最后一个数据
print(l[:])
print(l[:4])
print(l[2:])

输出结果为：
[2, 1, 4]
[3, 2, 1, 4, 6, 3, 2]
[3, 2, 1, 4]
[1, 4, 6, 3, 2]

print(l)
# 切片可以控制增长幅度，默认增长幅度为1
print(l[1:6:1])
# 打印从下标1开始的数字，每次隔一个
print(l[1:6:2])

输出结果为：
[3, 2, 1, 4, 6, 3, 2]
[2, 1, 4, 6, 3]
[2, 4, 3]

# 切片之负数下标
print(l)
# 下面显示的是为空，因为默认分片总是从左向右截取
# 即正常情况，分片左边的值一定小于右边的值
print(l[-2:-4])
print(l[-4:-2])
# 如果分片一定左边值比右边大，则步长参数需要使用负数
# 此案例为一个list直接正反颠倒提供了一种思路
print(l[-2:-4:-1])

输出结果为：
[3, 2, 1, 4, 6, 3, 2]
[]
[4, 6]
[3, 6]

删除列表中的值

# del 删除
a = [1,2,3,4,5,6]
del a[2]
print(a)

输出结果为：
[1, 2, 4, 5, 6]

其他操作

# 使用加号链接两个列表
a = [1,2,3,4,5]
b = [5,6,7,8,9]
d = ['a', 'b', 'c']
c = a + b + d
print(c)

输出结果为：
[1, 2, 3, 4, 5, 5, 6, 7, 8, 9, ‘a’, ‘b’, ‘c’]

# 使用乘号操作列表
# 列表直接跟一个整数相乘 
# 相当于把n个列表接在一起
a = [1,2,3,4,5]
b = a *3
print(b)

[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]