一小时入门 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中全部的非数字型变量都支持以下特点

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

列表

列表,在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}

'''