一小时入门 Python

因为需求, 需要用到py, 所以来学学py, 因为有java基础 一小时入门py语法是不成问题的, 但是仅仅入门基础语法而已, 不涉及算法,不涉及大数据,机器学习,人工智能, 但是py这么火爆,就在于这几个分支遍地开花,后续的路还好长啊

py的语法是真的简单, 跟java比,真的简单太多了, 而且他的代码很有条理, 因为他是严格控制缩进的,在一个缩进块中,就好比一个隐形的大括号一样,限制着变量的声明周期

---

命名:文件/标识符/关键字

• 标识符: 程序员定义的变量名,函数名
  • 可以由字母数字下划线组成
  • 不能用数字开头
  • 不能和已经存在的关键字重名
• 关键字: Python内置的标识符
• 文件名: 不推荐文件名以数字开头,否则不能通过import关键字导入其他文件使用

注释

• 单行注释使用 #
• 多行注释使用 ''' XXX '''

算数运算符

+ - * / == != > < >= <= %

加减乘除的使用方法和其他语言完全相同

//

取整数 求商

9//2=4

**

幂运算

2**3=8

列表常见运算

print([1,2]+[3,4])#[1, 2, 3, 4]

print([1,2]*2)#[1, 2, 1, 2]

print(3 in [1,2,3])#True
print(3 not in [1,2,3])#False

对全局列表使用+=操作,相当于extend函数**

def test(list):
    list+=list
    print(list)#[1, 3, 4, 1, 3, 4]
gl_list=[1,3,4]
test(gl_list)
print(gl_list)#[1, 3, 4, 1, 3, 4]

全局变量使用 = 赋值

不可变 全局变量在函数内部 使用 = ,这种赋值操作, 原全局变量不会被影响

gl_num=1
def test(num):
    print(num)#1
    num=2
    print(num)#2
    num+=3
    print(num)#5
test(gl_num)
print(gl_num)#1

在函数中, 如果全局变量是可变类型的, 如果在函数中往这个全局变量中添加内容了, 全局变量的值会受到影响

gl_num=[1,3,4]
def test(num):
    print(num)#[1, 3, 4]
    num+=[1]
    print(num)#[1, 3, 4, 1]
test(gl_num)
print(gl_num)#[1, 3, 4, 1]

赋值运算符

=
+=
-=
*=
/=      除法赋值运算符
//=     取整赋值运算符
%=      取模赋值运算符
**=     幂赋值运算符

转义运算符

\t 在控制台上输出一个制表符
\n 在控制台上输出一个换行符
\\ 反斜杠符
\' 输出单引号
\r 回车

变量

变量的命名:

• 区分大小写 Abc != abc
• 为了保证代码的质量, = 两边预留两个空格
• 所有单词全是小写字节
• 单词之间使用下划线连接 first_name

---

在py中,变量的类型是有不需要程序员指定,因为它是在运行时,由解释器自己推断出来的

例:

name="小明"    # str  字符串类型
age=18         # int 整形
sex= True      # bool 布尔类型  True False 首字母都是大写
height=1.78    # float 单精度小数类型
weiht=75.0     # float
weiht2=75      # int

• 数字型
  • int: 整形
  • float: 浮点型
  • bool:布尔型
    • True: 所有非0的数字
    • False:0
  • 复数类型: complex
    • 主要用于科学计算
• 非数字型:
  • str:字符串
  • 列表
  • 元组
  • 字典

在py2.0中
type(2 ** 32)  --> int
type(2 ** 64)  --> long
# 在py3.0中  全部都是 int, 在py中的计算能力,完爆其他语言
```py
print(type(2 ** 32))
print(type(2 ** 64))
print(type(2 ** 128))
print(type(2 ** 256))
print(type(2 ** 512))
print(type(2 ** 1024))

type函数可以直接查看变量的类型

print(type(name))  # 结果 <class 'str'>

• 相同类型之间的计算规则

  • 数值型变量之间的计算
  • bool型, True被转换成1 False被转换成0
  • 字符串之间使用 + 拼接成连续串

• 不同类型数据之间的计算规则

  • 字符串 * 整数 实现重复拼接串

print("$"*10)#$$$$$$$$$$

---

• 数字型变量和字符串之间不能进行其他类型操作

d=10
f="10.5"
g=True
print(d+f+g)#TypeError: unsupported operand type(s) for +: 'int' and 'str'

• 变量的输入输出

passwd = input("请输入密码")
print(passwd)
print(type(passwd))

• 类型转换

类型转换函数
int(X)#将输入转换成整数
float(X)#将输入转换成浮点型

• 变量的格式化输出

%s: 字符串
%d: 有符号十进制整数  %06d 表示输出的整形显示的位数, 不足的地方使用0补全
%f: 浮点型  %.02f 表示显示小数点后两位
%%: 输出%
q=999
print("格式化的字符串是  %06d "%q)#000999
w=123.123456
e=123.123456
r=123.123456
print("格式化的字符串%.2f"%w)#123.12
print("%.1f %.2f %.3f"% (w,e,r))#123.1 123.12 123.123
t=0.25
print("%.2f%%" % t)#0.25%

• 全局变量

全局变量推荐定义在全部代码的最上方

全局变量的推荐命名规则

g_XXX   gl_XXX

如何在 函数内部修改全局变量?

先使用 global 进行修饰,再修改

高级变量

如: 列表 元组 字典 字符串 公共方法

在python中全部的非数字型变量都支持以下特点

1. 都是一个序列, 也可以理解成容器
2. 取值 []
3. 遍历 for in
4. 计算长度,最大/小 值 比较 删除
5. 连接+ 重复*
6. 切片

列表

列表,在java叫数组

虽然列表可以存储不同类型的数据,但是绝大多数情况下, 用它存储相同类型的数据

使用 [] 定义, 数据之间使用 , 分隔

列表的索引从 0 开始

py中提供的常用操作

python 中对列表提供的操作
1. 增加   列表insert(索引,数据)      在指定位置插入数据
          列表append(数据)           在末尾追加数据
          列表extend(列表2)         将列表2的数据追加到列表
2. 修改   列表[索引]=新值            修改指定索引的数据
3. 删除   del列表[索引]              删除指定索引的数据
          列表.remove[数据]         删除第一个出现的指定的数据
          列表.pop                  删除末尾的数据
          列表.pop(索引)            删除指定索引的数据
          列表.clear                清空列表
4. 统计   len(列表)                 列表长度
          列表.count(数据)          数据在列表中出现的次数
5. 排序   列表.sort()               升序
          列表.sort(reserve=true)   降序排序
          列表.reserve()            逆序,反转
6. 取索引  列表.index(数据)          返回数据在列表中的索引

• 把变量从内存中删除掉

del name_list[0]
print(name_list[0])

• 第一个参数位置的self 直接忽略就行
• 迭代

for name in name_list:
    print(name)

元组

元组 Tuple 和列表类似,但是元组的元素 不能修改

通常使用 元组 存储不同类型的数据

元组表示多个元素组成的序列

下标从0开始

用户存储一串信息, 数据之间使用 逗号 分隔

• 定义元组

info_tuple = ("zhangsan",18,1.75)
print(type(info_tuple)) # <class 'tuple'>

• 取值

print(info_tuple[0])
print(info_tuple[1])
print(info_tuple[2])
# print(info_tuple[3])#tuple index out of range

• 取索引

print(info_tuple.index("zhangsan")) # 0

• 统计计数

print(info_tuple.count("zhangsan")) # 1

• 定义空元组,一般是不定义空元组的,但是没意义,因为不能再修改

empty_tuple = ()
print(type(empty_tuple))#<class 'tuple'>

• 定义一个元素的元组

single_touble1 = (5) # 解释器会忽略两个小括号
print(type(single_touble1))# <class 'int'>   被解释器解释成了int类型
single_touble2 = (5,) # 多加上一个逗号
print(type(single_touble2))#<class 'tuple'>

• 元组的应用场景
  • 作为入参: 可以使得函数一次性接受多个参数
  • 让列表不可变,保护数据的安全
  • 作为返回值: 可以使函数一次性返回多个值
  • 格式化字符串, 在print函数中,格式化字符串时, 格式化字符串后面的() 本质上就是一个元组

例:

print("年龄: %d   姓名:%s"%(123,"小明"))
info_tuple = ("zhangsan",18,1.75)
print(type(info_tuple)) # <class 'tuple'>
info_str="姓名:%s  年龄: %d  身高%.2f "% info_tuple
print(info_str)

• 列表转元组

my_list = [1,3,4,5]
my_list = tuple(my_list)
print(type(my_list)) # my_list

• 函数返回元组

def mea():
    a=1
    b=2
    return (a,b)
# 接受
result = mea()
# 使用
print(result[0])
print(result[1])
# 也可以这样接收, 注意, 变量的格式和元组的数保持一致
gl_a, gl_b = mea()

字典

字典是 无序对象 的集合 类似java中的 map,或者说是java中的一个对象

说它是无序,使用print输出时,每次的顺序不唯一

因为我们只关心通过key 取出 保存的数据,而不关心存储的顺序

字典使用{}定义

字典使用键值对存储数据, 键值对使用 逗号分隔

key 是索引,并且是 不可变类型的变量才能当key (列表,字典是可变类型,不能当成key)

value 是数据

键和值之间使用 : 冒号分隔

键是唯一的

值任意数据类型

*　定义字典

person={"name":"张三","age":23}

• 取值

# 取值
print(person["name"])# 入参位置的name是key
# print(xiaoming["name123"])# KeyError: 'name123'   key不存在,程序会报错

• 添加修改

# 添加/修改, 如果key存在了, 就是修改, key不存在就是添加
person["height"]=1.78
print(person)

• 删除

person.pop("age")
print(person)

• 统计键值对的数量

print(len(person))

• 合并字典

new_dir={"class":"大一"}
person.update(new_dir) # 如果被合并的字典中包含原有的键值对, 会覆盖旧值
print(person)

• 清空字典xiaoming

xiaoming.clear()
print(xiaoming)

• 遍历

for k in person:
    print(" value = %s "%person[k])

• 字典和列表搭配使用

将多个字典存入一个列表中,然后遍历列表对实现对字典批量处理的动作
list = [
        {},
        {},
        {}
        ]

if分支判断语句

if 要顶格写
if 条件1:
    XXX
elif ()or()or():
    XXX
else:
    XXX
严格控制缩进, tab 和 空格不能混用,容易乱

逻辑运算符

与  and
或  or
非  not
条件1 and 条件2
条件1 or 条件2
对条件取反
not 条件1
not 条件2

循环

• for循环

for 变量 in 集合:
    XXX
else:
    XXX

• while循环

i=0
while i<5:
    print("i= %d"%i)
    #i=i+1
    i+=1

函数

格式如下

def 函数名():
    XXX
    XXX
def 函数名():
    XXX
    XXX
    return XXX

内置函数

• 随机数

import random
n = random.randint(1,5)# 1 <= n <= 5
m = random.randint(5,5)# n = 5
# s = random.randint(10,5)# 第一个数大于第二个数则保存
print("age== %d "%n)

缺省参数

• 缺省参数, 简化人们的编码

gl_list=[5,126,7]
gl_list.sort()
print(gl_list) # 默认正序
gl_list.sort(reverse=True) # 缺省参数位置,可以设置逆序
print(gl_list)

• 指定缺省参数的默认值

def print_info(name,gender=True):
    default_gender="男生"
    if not gender:
        default_gender = "女生"
    print("%s 是 %s"%(name,default_gender))
print_info("小明")
print_info("小明",False)

注意事项:缺省参数必须保证它出现在 !!! 参数列表的末尾 !!!

• 如何调用含有多个参数, 如果有多个参数的话, 中间位置的参数最好也设置上默认值

def print_info(name,age="",gender=True):
    default_gender="男生"
    if not gender:
        default_gender = "女生"
    print("%s 是 %s"%(name,default_gender))
print_info("小明")
print_info("小明",gender=False)

• 多值参数

在参数名前添加一个 * 可以接收元组

在参数名前添加两个 * 可以接收字典

习惯用下面的方式命名:

• *args :存放元组
• **kw :存放字典数据

def demo(num,*nums,**person):
    print(num)
    print(nums)
    print(person)
demo(1)
'''
1
()
{}
'''
demo(1,23,4,5,6)
'''
1
(23, 4, 5, 6)
{}
'''
demo(1,23,4,5,6,name="张三",age=18)
'''
1
(23, 4, 5, 6)
{'name': '张三', 'age': 18}
'''
# 对比去除* 的写法, 其实用户在使用时变麻烦了,多增加了一个小括号
def print_info1(name):
    print(name)
print_info1((1,2,3,4))#(1, 2, 3, 4)

元组和字段的拆包

def demo(*args,**kwargs):
    print(args)
    print(kwargs)
gl_nums=(1,2,3)
gl_dir={"name":"李四","age":12}
demo(gl_nums,gl_dir)
'''
 下面的运行结果其实是差强人意的, 需要进行拆包
((1, 2, 3), {'name': '李四', 'age': 12})
{}
'''
# 不拆包,直接调用
demo(1,2,3,name="李四",age=123)
'''
(1, 2, 3)
{'name': '李四', 'age': 123}
'''
# 拆包
demo(*gl_nums,**gl_dir)
'''
(1, 2, 3)
{'name': '李四', 'age': 12}
'''