目录

环境安装 

python语法

打印语句

 注释

变量

变量声明

变量类型

 boolean类型

占位符

 控制数据精度

 输入输出

 条件控制

循环语句

while循环

for循环

函数

None类型

 数据容器

列表

元组

字符串

序列

集合

字典 

---

环境安装 

1、安装python运行环境

Welcome to Python.org

2、安装python的集成开发环境 pyCharm

python语法

打印语句

 注释

"""
多行注释
"""

# 单行注释
# 打印字符串内容
print("hello world")

变量

变量声明

变量是存储在内存中的值，这就意味着在创建变量时会在内存中开辟一个空间。

基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。

因此，变量可以指定不同的数据类型，变量可以存储整数，小数或字符。

在java或者c语言，定义一个变量都是需要类型的，比如

int a=0；char ch='a'

但是，Python 中的变量赋值不需要赋予数据类型。

a=10 #将整形数据10赋值给变量啊
print("a= ",a)
a="hello" #将字符串赋值给变量a
print("a= ",a)
a=b=c=9 #也可以连续赋值
print("a= ",a," b= ",b," c= ",c)

 一个变量，可以被赋值给不同类型的数据

变量类型

整形和浮点数

在java中，整数数据是int和long类型，小数包括float（四字节，单精度浮点数）和double（八字节，双精度浮点数）

python包括complex（复数）类型，Python 只有一种小数类型，就是 float（这里float扩展为了8字节，等同于double）

long 类型只存在于 Python2.X 版本中，在 2.2 以后的版本中，int 类型数据溢出后会自动转为long类型。在 Python3.X 版本中 long 类型被移除，使用 int 替代。

使用type（）函数可以检测数据类型

a=10     #int类型数据
print(type(a))

a=2147483647+10 #这里 2147483647是int的最大值  int会自动转化为long类型
print("a=",a);
print(type(a));

a=12.3   #Python 只有一种小数类型，就是 float
print(type(a))

#复数
a=complex(1,1);
print("a=",a);
print(type(a))

 字符串类型

a='1'
print("a=",a)
print(type(a))

a="123"
print("a=",a)
print(type(a))

python是没有char类型的，一个字符也是字符串类型

 字符串也可以使用+拼接

 boolean类型

和c语言一样，0表示假，非0表示真。只不过一般用1表示真

但是python的True和False，首字母大写

占位符

message="%s,%d,%f" %("张三",123,23.9)
# %s 将张三填入  %d将123填入 %f，将9以小数格式填入
print(message)

 控制数据精度

使用m.n可以设置数据精度（m设置宽度，n控制小点数的精度）

小数中，小数点和小数部分也会在m中充当长度，小数数据截断会四舍五入

print("%5d" %12)   #设置12这个整数长度为5位,数据长度不足左补空格  [空格][空格][空格]12
print("%1d" %12)   #设置12这个整数长度为1位,数据长度大 限制丢失
print("%7.2f" %12.276)   #设置数据长度为7位，保留两位小数 [空格][空格]12.28

- ---指定左对齐输出。
0---指定空位填零。

 

 输入输出

使用input（）语句，从键盘获取数据 ；获取到的数据类型都是str

ch=input()
print(ch)
print(type(ch))

 条件控制

if 条件语句 ：

 执行语句

elif 条件语句：

 执行语句

else 条件语句：

 执行语句

使用缩进表示以上的层次关系 同一个缩进是对应的判断体系

#猜数字游戏
num=random.randint(0,100)
print(num)
while(True):
    print("请输入0~100的整数")

    guess=(int)(input())  #这里 应该对输入判断 应该全是数字，且不是小数 为了方便，没有展示
    if(guess>num):
        print("猜大了")
    elif(guess<num):
        print("猜小了")
    else:
        print("猜对了")
        break
    print("------")     #这行和if语句缩进并列 相当于循环一次执行一次

print("游戏结束")  #这行和while循环缩进并列 相当于循环结束后执行

 

循环语句

while循环

str="hello world"

i=0
while i<len(str):
    print(str[i])
    i+=1

for循环

str="hello world"

#str字符串 每次查找到一个字符 结果就赋值给变量 x
for x in str:
    print(x)

range（）语句

range（x，y，z）语句，生成一定范围内的数字集合[x,y)，左闭右开区间，x默认为0，z是步长，默认为1

a=range(0,10)   #  0 1 2 3 4 5 6 7  8 9
for x in a:
    print(x)

a=range(6,10)   #  6 7  8 9
for x in a:
    print(x)

a=range(2,10,2)   # [2.10) 内数据 步长为2 结果：2 4   6  8
for x in a:
    print(x)

变量作用域

for x in range(0,4):
    print(x)

print(x)    #没有遵守规范,但是可以执行

最外层这行代码，在规范来说都是不合法的。因为x是在for循环内部定义的，作用域也应该在for循环内部，其生命周期在for循环结束也结束了。但是python中并没有遵守这一个准则，这一行代码可以正常执行。

不过为了符合编程规范，最好还是不要使用此特殊情况。

控制语句	描述
break 语句	在语句块执行过程中终止循环，并且跳出整个循环
continue 语句	在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。

函数

使用函数，可以实现某一逻辑的功能

# 定义 sum函数 计算x+y
def  add(x,y):
    z=x+y
    return z
#return 表示这个函数 将值返回

z=add(2,4) #函数调用 并接收返回结果
print(z)

None类型

None是一个特殊的字面常量，表示空的，没有意义

在我们定义的函数没有返回值时，看似没有结果返回，实际上是返回了一个None

# 定义 sum函数 计算x+y
def  add(x,y):
      z=x+y
      print(z)


ret=add(2,3)
print("ret=",{ret})
print(type(ret))

 变量在函数中的作用域

1.  变量分为局部变量与全局变量
2. 由某对象或某个函数所创建的变量通常都是局部变量，只能被内部引用，而无法被其它对象或函数引用。
3. 全局变量既可以是某对象函数创建，也可以是在本程序任何地方创建。全局变量是可以被本程序所有对象或函数引用。
4. global关键字的作用是可以使得一个局部变量为全局变量。

 global关键字可以声明 某一个变量是全局变量。函数内部声明z变量是全局变量，函数内部的z和函数外部的z就成为了同一个变量。

 数据容器

数据容器可以存储大量数据。包括：列表，元组，字典，字符串，集合五类

列表

列表的数据项不需要具有相同的类型，有序，可修改

#定义一个列表 并且赋值
a=["123",23]
print(a)

#定义空列表
b=[]
print(b)

c=list()
print(c)

 1、列表索引

列表索引 从左向右 下标为0，1，2……，从右向左是-1，-2，-3……

print("正向输出")
list=["汪汪","糖豆","WiFi","章鱼","大鹅"]
#从左向右 下标为 0 1 2 3 4 正向输出每一个元素
i=0
while(i<len(list)):
    print(list[i])
    i+=1
print("逆向输出")
#从右向左 下标为-1 -2 -3 -4 -5 逆向输出结果
i=-1
count=0  #记录遍历元素的次数
while(count<len(list)):
    count+=1
    print(list[i])
    i-=1

2、 列表嵌套

#列表嵌套
list=[[1,2,3],["张三",10,11],0,-9]

print(list[0])  #得到的是0下标的元素  也即是一整个列表 [1,2,3]
print(list[1][0]) #得到第二个列表中 第一个元素 ”张三“

3、内置函数

python包含一些内置函数，实现了某些功能

#定义一个列表 并且赋值
a=["123","hi","张三"]
#1、求列表元素长度 len()
print(len(a))
####!!!! 注意,一旦涉及到了元素大小的比较,一定是同一类型的元素才可以比较
#2、列表最大值
print(max(a))
#3、列表最小值
print(min(a))

4、列表方法

如果将函数放在某一个类中，就称它为方法，可以通过类对象.方法名调用

序号	方法
1	list.append(obj) 在列表末尾添加新的对象
2	list.count(obj) 统计某个元素在列表中出现的次数
3	list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj) 从列表中找出某个值第一个匹配项的索引位置  元素不存在,报错
5	list.insert(index, obj) 将对象插入列表
6	list.pop([index=-1])     根据下标删除 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj)   根据元素删除 移除列表中某个值的第一个匹配项  元素不存在,报错
8	del 列表[index]    根据下标删除 删除某一下标的元素  不返回该元素的值
9	list.reverse() 反转列表中元素
10	list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序 默认升序，降序让 reverse=True ，key表示指定排序规则的函数

#定义一个列表 并且赋值
a=["hi","张三","123"]

#1、获取某一个元素 第一次出现的下标 如果此元素不存在 会报错
print( a.index("123"))    #结果2

#2、添加元素 在列表末尾添加元素
a.append("123")
print(a)  #结果 hi","张三","123","123"

#3、在列表末尾 添加一个列表
a.extend(["新的列表","元素2"])
print(a)   #结果 ['hi', '张三', '123', '123', '新的列表', '元素2']

#4、在指定下标处添加元素或者列表
a.insert(2,"插入元素")
print(a)   #结果  ['hi', '张三', '插入元素', '123', '123', '新的列表', '元素2']

a.insert(2,["插入元组1","插入元组2"])
print(a)  #结果 ['hi', '张三', ['插入元组1', '插入元组2'], '插入元素', '123', '123', '新的列表', '元素2']

#5、删除元素 根据下标删除
del a [0]  #删除下标为0的元素
del a[-1] #删除下标为-1的元素
print(a)  #结果  ['张三', ['插入元组1', '插入元组2'], '插入元素', '123', '123', '新的列表']

a.pop() #删除某一个下标的元素 默认下标为-1 也就是删除最后一个元素
print(a) #结果  ['张三', ['插入元组1', '插入元组2'], '插入元素', '123', '123']

#6、删除出现的元素 只删除第一次出现的
a.remove("123") #删除第一个出现的123
print(a)  #结果  ['张三', ['插入元组1', '插入元组2'], '插入元素', '123']

#7、统计元素出现的次数
print(a.count("123"))

#8、反转列表元素
a.reverse()   #不会返回新的列表 直接修改此列表
print(a)

#9、列表元素排序
#这时 列表元素包含 嵌套的列表和字符串,无法比较大小 我们删除内部列表
a.pop(2)
print(a)
# 对 ['123', '插入元素', '张三']这个列表排序
a.sort()
print(a)  #升序排序
a.sort(reverse=True)
print(a)  #降序排序

元组

元组在列表的基础上，要求不可修改 支持下标索引

1、定义元组

元组使用小括号，列表使用方括号。

#定义元组
a=(1,2,3)  #定义元组 并赋值
b=()       #定义空元组
c=tuple()  #定义空元组

元组中只包含一个元素时，需要在元素后面添加逗号

 2、内置函数

#内置函数
print(max(tup))
print(min(tup))
print(len(tup))

3、方法

方法	说明
tuple.index(obj)	得到obj这个元素第一次出现的下标 元素不存在报错
del（tuple）	删除元组类型变量
tuple.count(obj)	得到obj这个元素的出现次数 元素不存在就是0

tup=(1,2,3)
#1、得到某一个元素第一次出现的下标 元素不存在报错
print(tup.index(2))
#2、不可以对元组内容修改 但是可以删除元组(不是删除元组内容,而是直接删除这个变量)
del(tup)
# print(tup) 报错 元素不存在

字符串

字符串也是一种数据容器，因为是字符的集合

字符串也是不可以进行修改的

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

str="hello"

#1、使用加号 可以进行字符串拼接
print(str+" world")
#2、使用*可以输出多次
print(str*3) #输出三次hello

 常用方法

方法	描述
string.count(str, beg=0, end=len(string))	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.find(str, beg=0, end=len(string))	检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是，返回开始的索引值，否则返回-1
string.rfind(str, beg=0,end=len(string) )	返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。
string.replace(str,obj)	将字符串的所有str元素，替换为obj元素，返回新的字符串
string.index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.upper()	转换 string 中的小写字母为大写
string.lower()	转换 string 中所有大写字符为小写.
string.replace(str1, str2,  num=string.count(str1))	把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string.strip(obj)	去除首尾obj，没有传入参数时，默认去除字符串前后空格。这里会将obj元素划分为子串，只要是首位字符包括于obj字符串，就会被删除

获取到某一下标的元素
print(str[1])
#2、获取元素第一次出现的下标
print(str.find("l"))
#得到元素最后一次出现的下标值
print(str.rfind("l"))
#3、获取到字符串长度
print(len(str))
#4、元素替换
print(str.replace("l","N"))
#5、元素根据空格进行分割  得到一个列表
print(str.split(" "))
#6、去除前后空格
ret=str.strip()
print(ret)

print(ret.strip("12")) #将12看作子串 会删除掉首尾的1和2  结果 Hello World
#7、统计某一个元素的出现次数
print("打印空格出现的次数",{str.count(" ")})

序列

序列：内容连续、有序、可以按照索引查找的数据容器

列表，元组，字符串都是序列

序列可以支持切片操作，就是从序列中截取某一部分元素，得到一个新的序列

左闭右开区间

序列[起始下标：结束下标：步长]

• 起始下标：表示从何处开始，默认从0开始
• 结束下标：表示从何处结束，默认数组长度结束
• 步长：表示取元素的间隔 步长为1，表示拿到范围内的所有元素，步长为2，表示跳过一个元素取，例如[2,6]中,步长为2，取出2 4 6 
• 步长为负数表示倒着取数据

tuple=(0,1,2,3,4,5,6,7)

#1、从0开始 到长度结束 步长为1 也就是拿到所有数据
tmp=tuple[::1]
print(tmp)
#2、从0开始 到长度结束 步长为2 也就是拿到所有偶数数据
tmp=tuple[::2]
print(tmp)
#3、拿到3 4 5 6数据  左闭右开区间  元素下标取[3,7)，也就是3 4 5 6
tmp=tuple[3:7:1]
print(tmp)
#4、逆序输出
tmp=tuple[::-1]
print(tmp)
#5、逆序输出 步长为2
tmp=tuple[::-2]
print(tmp)
#6、逆序输出5 4 3
   #分析:步长-1 开始下标5 结束下标3 因为是开区间,结束位置值是2
tmp=tuple[5:2:-1]
print(tmp)

集合

集合元素不可以重复，且内部无序

 集合会去重并且内部无序

因为集合内部无序（存储顺序和输入顺序并不符合）所以不支持下标访问（也就不能使用while循环遍历集合）

方法	说明
set.add(obj)	给集合添加一个元素（元素可以是字符串，整体添加字符串）（不添加重复元素）
set.update(obj)	给集合添加元素，如果obj是字符串，会添加obj的每一个字符（不添加重复元素）
set.remove(obj)	从集合删除obj元素，如果元素不存在报错
set.discard(obj)	从集合删除obj元素，如果元素不存在不会报错
set.pop()	随机从集合删除一个元素，并且返回这个元素值
set.difference(set1)	得到两个集合的差集
set.union(set1)	得到两个集合的并集
set.intersection(set1)	得到两个集合的交集

set={1,2,3,"张三","123","hello"}
print(set)

#1、给集合添加元素  添加字符串,整体添加
set.add("world")
print(set)

#2、删除某一个元素
set.remove("world")
print(set)
set.discard("123")
print(set)
#3、随机从集合删除一个元素
print("随机删除的元素",{set.pop()})
print(set)

#4、将元素添加到集合  添加字符串
set.update("hi")
print(set)

#5、得到两个集合的差集
set1={1,2,3,"张三"}
set2={2,3,0,"李四"}
print("差集：",set1.difference(set2))   #得到set1集合中 set2集合没有的元素

#6、取两个集合的并集
print("并集：",set1.union(set2))  #两个集合的并集
# 7、取两个集合的交集
print("交集：",set1.intersection(set2))

#8、修改集合1的内容 为两个集合的差集
set1.difference_update(set2)
print(set1)

#9、修改集合1的内容 为两个集合的交集
set1={1,2,3,"张三"}
set2={2,3,0,"李四"}
set1.intersection_update(set2)
print(set1)

字典 

以键值对的形式存储的数据 根据key访问value

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，对应的value会是最后一次的赋值

2）键必须不可变，可以用数字，字符串或元组充当，用列表就不行

1、定义字典

字典的每个键值 key:value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

a =dict()  #定义空字典
print(type(a))

dic={"name":"汪汪","password":123}
print(dic)


#定义嵌套字典

dic1={
    "1" :{
        "name":"张三",
        "password":123
    },
    "2": {
        "name": "王五",
        "password": 1232
    }
}

2、元素获取、添加、修改、删除

dic={"name":"汪汪","password":123}
#1、根据key 访问value  如果key不存在 报错
print(dic["name"])   #得到 汪汪
print(dic["password"])  # 得到 123

#2、value更新
dic["name"]="two 倩"
print(dic)

#3、添加一个键值对
dic["score"]=90
print(dic)

#4、删除键值对
del dic["score"] #删除指定键值对
print(dic)
dic.clear() #清空所有键值对
print(dic)
del dic #删除dic遍历
#print(dic)  #元素不存在

3、常用方法

方法	说明
dict.get(key, default=None)	返回指定键的值，如果值不在字典中返回default值
dict.keys()	以列表返回一个字典所有的键
dict.items()	将键值对信息包装为元组，多个元组包装为一个列表，返回列表
dict.update(dict2)	把字典dict2的键/值对更新到dict里 key已经存在就覆盖value，不存在就添加
pop(key[,default])	删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 key值不存在，报错

dic={
    "1" :{
        "name":"张三",
        "password":123
    },
    "2": {
        "name": "王五",
        "password": 1232
    }
}

#1、获取某一元素
print(dic["1"]["name"])  #张三

print(dic.get("1"))#{'name': '张三', 'password': 123}

print(dic.get("3"))#None

#2、得到所有的key
keys=dic.keys()
for x in keys:
    print(dic[x])
#3、得到键值对信息
print(dic.items())  # dict_items([('1', {'name': '张三', 'password': 123}), ('2', {'name': '王五', 'password': 1232})])
items=dic.items()
for x in items:  # 得到的 x 形如 ('1', {'name': '张三', 'password': 123})
    print(x[0])   #1
    print(x[1]["name"]) #张三
    print(x[1]["password"]) #123

#4、更新 将dic1的键值对添加入dic 如果key重复,value覆盖,不重复 直接添加
dic1={
    "1" :{
        "name":"张无忌",
        "password":123
    },
    "3": {
        "name": "王五",
        "password": 1232
    }
}
dic.update(dic1)
print(dic)  #{'1': {'name': '张无忌', 'password': 123}, '2': {'name': '王五', 'password': 1232}, '3': {'name': '王五', 'password': 1232}}

#5、删除 根据key删除一个键值对 key不存在 报错
print(dic.pop("3"))
print(dic)